1/*
2 This file is part of the WebKit open source project.
3 This file has been generated by generate-bindings.pl. DO NOT MODIFY!
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public
7 License as published by the Free Software Foundation; either
8 version 2 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public License
16 along with this library; see the file COPYING.LIB. If not, write to
17 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 Boston, MA 02110-1301, USA.
19*/
20
21#include "config.h"
22#include "JSInternals.h"
23
24#include "ActiveDOMObject.h"
25#include "DOMIsoSubspaces.h"
26#include "DOMPromiseProxy.h"
27#include "Document.h"
28#include "IDLTypes.h"
29#include "JSAbstractRange.h"
30#include "JSCSSStyleDeclaration.h"
31#include "JSDOMAttribute.h"
32#include "JSDOMBinding.h"
33#include "JSDOMConvertAny.h"
34#include "JSDOMConvertBase.h"
35#include "JSDOMConvertBoolean.h"
36#include "JSDOMConvertBufferSource.h"
37#include "JSDOMConvertCallbacks.h"
38#include "JSDOMConvertEventListener.h"
39#include "JSDOMConvertInterface.h"
40#include "JSDOMConvertNullable.h"
41#include "JSDOMConvertNumbers.h"
42#include "JSDOMConvertPromise.h"
43#include "JSDOMConvertSequences.h"
44#include "JSDOMConvertSerializedScriptValue.h"
45#include "JSDOMConvertStrings.h"
46#include "JSDOMExceptionHandling.h"
47#include "JSDOMGlobalObject.h"
48#include "JSDOMOperation.h"
49#include "JSDOMOperationReturningPromise.h"
50#include "JSDOMPointReadOnly.h"
51#include "JSDOMRect.h"
52#include "JSDOMRectList.h"
53#include "JSDOMRectReadOnly.h"
54#include "JSDOMURL.h"
55#include "JSDOMWindow.h"
56#include "JSDOMWrapperCache.h"
57#include "JSDocument.h"
58#include "JSElement.h"
59#include "JSEventListener.h"
60#include "JSFetchResponse.h"
61#include "JSFile.h"
62#include "JSGCObservation.h"
63#include "JSHTMLImageElement.h"
64#include "JSHTMLInputElement.h"
65#include "JSHTMLLinkElement.h"
66#include "JSHTMLSelectElement.h"
67#include "JSInternalSettings.h"
68#include "JSInternalsMapLike.h"
69#include "JSInternalsSetLike.h"
70#include "JSMallocStatistics.h"
71#include "JSMemoryInfo.h"
72#include "JSMockPageOverlay.h"
73#include "JSNode.h"
74#include "JSNodeList.h"
75#include "JSRange.h"
76#include "JSSVGSVGElement.h"
77#include "JSStringCallback.h"
78#include "JSStyleSheet.h"
79#include "JSTypeConversions.h"
80#include "JSVoidCallback.h"
81#include "JSWebAnimation.h"
82#include "JSWindowProxy.h"
83#include "JSXMLHttpRequest.h"
84#include "ScriptExecutionContext.h"
85#include "SerializedScriptValue.h"
86#include "WebCoreJSClientData.h"
87#include <JavaScriptCore/HeapAnalyzer.h>
88#include <JavaScriptCore/JSArray.h>
89#include <JavaScriptCore/JSCInlines.h>
90#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>
91#include <JavaScriptCore/JSString.h>
92#include <JavaScriptCore/ObjectConstructor.h>
93#include <JavaScriptCore/SlotVisitorMacros.h>
94#include <JavaScriptCore/SubspaceInlines.h>
95#include <wtf/GetPtr.h>
96#include <wtf/PointerPreparations.h>
97#include <wtf/URL.h>
98
99#if ENABLE(APPLE_PAY)
100#include "JSMockPaymentCoordinator.h"
101#endif
102
103#if ENABLE(ATTACHMENT_ELEMENT)
104#include "JSHTMLAttachmentElement.h"
105#endif
106
107#if ENABLE(CONTENT_FILTERING)
108#include "JSMockContentFilterSettings.h"
109#endif
110
111#if ENABLE(ENCRYPTED_MEDIA)
112#include "JSMediaKeySession.h"
113#include "JSMediaKeys.h"
114#include "JSMockCDMFactory.h"
115#endif
116
117#if ENABLE(MEDIA_SESSION)
118#include "JSMediaSession.h"
119#include "JSMediaSessionActionDetails.h"
120#endif
121
122#if ENABLE(MEDIA_SESSION) || ENABLE(MEDIA_STREAM)
123#include "JSImageData.h"
124#endif
125
126#if ENABLE(MEDIA_SOURCE)
127#include "JSSourceBuffer.h"
128#endif
129
130#if ENABLE(MEDIA_STREAM)
131#include "JSAudioTrack.h"
132#include "JSMediaStream.h"
133#include "JSMediaStreamTrack.h"
134#endif
135
136#if ENABLE(SERVICE_WORKER)
137#include "JSServiceWorker.h"
138#endif
139
140#if ENABLE(VIDEO)
141#include "JSHTMLMediaElement.h"
142#include "JSHTMLVideoElement.h"
143#include "JSTextTrack.h"
144#include "JSTextTrackCueGeneric.h"
145#include "JSTimeRanges.h"
146#endif
147
148#if ENABLE(WEBGL)
149#include "JSWebGLRenderingContext.h"
150#endif
151
152#if ENABLE(WEBXR)
153#include "JSWebXRTest.h"
154#endif
155
156#if ENABLE(WEB_AUDIO)
157#include "JSAudioContext.h"
158#include "JSBaseAudioContext.h"
159#endif
160
161#if ENABLE(WEB_AUTHN)
162#include "JSMockWebAuthenticationConfiguration.h"
163#endif
164
165#if ENABLE(WEB_RTC)
166#include "JSRTCPeerConnection.h"
167#include "JSRTCRtpSFrameTransform.h"
168#endif
169
170
171namespace WebCore {
172using namespace JSC;
173
174String convertEnumerationToString(Internals::PageOverlayType enumerationValue)
175{
176 static const NeverDestroyed<String> values[] = {
177 MAKE_STATIC_STRING_IMPL("view"),
178 MAKE_STATIC_STRING_IMPL("document"),
179 };
180 static_assert(static_cast<size_t>(Internals::PageOverlayType::View) == 0, "Internals::PageOverlayType::View is not 0 as expected");
181 static_assert(static_cast<size_t>(Internals::PageOverlayType::Document) == 1, "Internals::PageOverlayType::Document is not 1 as expected");
182 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
183 return values[static_cast<size_t>(enumerationValue)];
184}
185
186template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, Internals::PageOverlayType enumerationValue)
187{
188 return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue));
189}
190
191template<> std::optional<Internals::PageOverlayType> parseEnumeration<Internals::PageOverlayType>(JSGlobalObject& lexicalGlobalObject, JSValue value)
192{
193 auto stringValue = value.toWTFString(&lexicalGlobalObject);
194 if (stringValue == "view")
195 return Internals::PageOverlayType::View;
196 if (stringValue == "document")
197 return Internals::PageOverlayType::Document;
198 return std::nullopt;
199}
200
201template<> const char* expectedEnumerationValues<Internals::PageOverlayType>()
202{
203 return "\"view\", \"document\"";
204}
205
206String convertEnumerationToString(Internals::CachePolicy enumerationValue)
207{
208 static const NeverDestroyed<String> values[] = {
209 MAKE_STATIC_STRING_IMPL("UseProtocolCachePolicy"),
210 MAKE_STATIC_STRING_IMPL("ReloadIgnoringCacheData"),
211 MAKE_STATIC_STRING_IMPL("ReturnCacheDataElseLoad"),
212 MAKE_STATIC_STRING_IMPL("ReturnCacheDataDontLoad"),
213 };
214 static_assert(static_cast<size_t>(Internals::CachePolicy::UseProtocolCachePolicy) == 0, "Internals::CachePolicy::UseProtocolCachePolicy is not 0 as expected");
215 static_assert(static_cast<size_t>(Internals::CachePolicy::ReloadIgnoringCacheData) == 1, "Internals::CachePolicy::ReloadIgnoringCacheData is not 1 as expected");
216 static_assert(static_cast<size_t>(Internals::CachePolicy::ReturnCacheDataElseLoad) == 2, "Internals::CachePolicy::ReturnCacheDataElseLoad is not 2 as expected");
217 static_assert(static_cast<size_t>(Internals::CachePolicy::ReturnCacheDataDontLoad) == 3, "Internals::CachePolicy::ReturnCacheDataDontLoad is not 3 as expected");
218 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
219 return values[static_cast<size_t>(enumerationValue)];
220}
221
222template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, Internals::CachePolicy enumerationValue)
223{
224 return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue));
225}
226
227template<> std::optional<Internals::CachePolicy> parseEnumeration<Internals::CachePolicy>(JSGlobalObject& lexicalGlobalObject, JSValue value)
228{
229 auto stringValue = value.toWTFString(&lexicalGlobalObject);
230 if (stringValue == "UseProtocolCachePolicy")
231 return Internals::CachePolicy::UseProtocolCachePolicy;
232 if (stringValue == "ReloadIgnoringCacheData")
233 return Internals::CachePolicy::ReloadIgnoringCacheData;
234 if (stringValue == "ReturnCacheDataElseLoad")
235 return Internals::CachePolicy::ReturnCacheDataElseLoad;
236 if (stringValue == "ReturnCacheDataDontLoad")
237 return Internals::CachePolicy::ReturnCacheDataDontLoad;
238 return std::nullopt;
239}
240
241template<> const char* expectedEnumerationValues<Internals::CachePolicy>()
242{
243 return "\"UseProtocolCachePolicy\", \"ReloadIgnoringCacheData\", \"ReturnCacheDataElseLoad\", \"ReturnCacheDataDontLoad\"";
244}
245
246String convertEnumerationToString(Internals::ResourceLoadPriority enumerationValue)
247{
248 static const NeverDestroyed<String> values[] = {
249 MAKE_STATIC_STRING_IMPL("ResourceLoadPriorityVeryLow"),
250 MAKE_STATIC_STRING_IMPL("ResourceLoadPriorityLow"),
251 MAKE_STATIC_STRING_IMPL("ResourceLoadPriorityMedium"),
252 MAKE_STATIC_STRING_IMPL("ResourceLoadPriorityHigh"),
253 MAKE_STATIC_STRING_IMPL("ResourceLoadPriorityVeryHigh"),
254 };
255 static_assert(static_cast<size_t>(Internals::ResourceLoadPriority::ResourceLoadPriorityVeryLow) == 0, "Internals::ResourceLoadPriority::ResourceLoadPriorityVeryLow is not 0 as expected");
256 static_assert(static_cast<size_t>(Internals::ResourceLoadPriority::ResourceLoadPriorityLow) == 1, "Internals::ResourceLoadPriority::ResourceLoadPriorityLow is not 1 as expected");
257 static_assert(static_cast<size_t>(Internals::ResourceLoadPriority::ResourceLoadPriorityMedium) == 2, "Internals::ResourceLoadPriority::ResourceLoadPriorityMedium is not 2 as expected");
258 static_assert(static_cast<size_t>(Internals::ResourceLoadPriority::ResourceLoadPriorityHigh) == 3, "Internals::ResourceLoadPriority::ResourceLoadPriorityHigh is not 3 as expected");
259 static_assert(static_cast<size_t>(Internals::ResourceLoadPriority::ResourceLoadPriorityVeryHigh) == 4, "Internals::ResourceLoadPriority::ResourceLoadPriorityVeryHigh is not 4 as expected");
260 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
261 return values[static_cast<size_t>(enumerationValue)];
262}
263
264template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, Internals::ResourceLoadPriority enumerationValue)
265{
266 return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue));
267}
268
269template<> std::optional<Internals::ResourceLoadPriority> parseEnumeration<Internals::ResourceLoadPriority>(JSGlobalObject& lexicalGlobalObject, JSValue value)
270{
271 auto stringValue = value.toWTFString(&lexicalGlobalObject);
272 if (stringValue == "ResourceLoadPriorityVeryLow")
273 return Internals::ResourceLoadPriority::ResourceLoadPriorityVeryLow;
274 if (stringValue == "ResourceLoadPriorityLow")
275 return Internals::ResourceLoadPriority::ResourceLoadPriorityLow;
276 if (stringValue == "ResourceLoadPriorityMedium")
277 return Internals::ResourceLoadPriority::ResourceLoadPriorityMedium;
278 if (stringValue == "ResourceLoadPriorityHigh")
279 return Internals::ResourceLoadPriority::ResourceLoadPriorityHigh;
280 if (stringValue == "ResourceLoadPriorityVeryHigh")
281 return Internals::ResourceLoadPriority::ResourceLoadPriorityVeryHigh;
282 return std::nullopt;
283}
284
285template<> const char* expectedEnumerationValues<Internals::ResourceLoadPriority>()
286{
287 return "\"ResourceLoadPriorityVeryLow\", \"ResourceLoadPriorityLow\", \"ResourceLoadPriorityMedium\", \"ResourceLoadPriorityHigh\", \"ResourceLoadPriorityVeryHigh\"";
288}
289
290String convertEnumerationToString(Internals::AutoFillButtonType enumerationValue)
291{
292 static const NeverDestroyed<String> values[] = {
293 MAKE_STATIC_STRING_IMPL("None"),
294 MAKE_STATIC_STRING_IMPL("Contacts"),
295 MAKE_STATIC_STRING_IMPL("Credentials"),
296 MAKE_STATIC_STRING_IMPL("StrongPassword"),
297 MAKE_STATIC_STRING_IMPL("CreditCard"),
298 };
299 static_assert(static_cast<size_t>(Internals::AutoFillButtonType::None) == 0, "Internals::AutoFillButtonType::None is not 0 as expected");
300 static_assert(static_cast<size_t>(Internals::AutoFillButtonType::Contacts) == 1, "Internals::AutoFillButtonType::Contacts is not 1 as expected");
301 static_assert(static_cast<size_t>(Internals::AutoFillButtonType::Credentials) == 2, "Internals::AutoFillButtonType::Credentials is not 2 as expected");
302 static_assert(static_cast<size_t>(Internals::AutoFillButtonType::StrongPassword) == 3, "Internals::AutoFillButtonType::StrongPassword is not 3 as expected");
303 static_assert(static_cast<size_t>(Internals::AutoFillButtonType::CreditCard) == 4, "Internals::AutoFillButtonType::CreditCard is not 4 as expected");
304 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
305 return values[static_cast<size_t>(enumerationValue)];
306}
307
308template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, Internals::AutoFillButtonType enumerationValue)
309{
310 return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue));
311}
312
313template<> std::optional<Internals::AutoFillButtonType> parseEnumeration<Internals::AutoFillButtonType>(JSGlobalObject& lexicalGlobalObject, JSValue value)
314{
315 auto stringValue = value.toWTFString(&lexicalGlobalObject);
316 if (stringValue == "None")
317 return Internals::AutoFillButtonType::None;
318 if (stringValue == "Contacts")
319 return Internals::AutoFillButtonType::Contacts;
320 if (stringValue == "Credentials")
321 return Internals::AutoFillButtonType::Credentials;
322 if (stringValue == "StrongPassword")
323 return Internals::AutoFillButtonType::StrongPassword;
324 if (stringValue == "CreditCard")
325 return Internals::AutoFillButtonType::CreditCard;
326 return std::nullopt;
327}
328
329template<> const char* expectedEnumerationValues<Internals::AutoFillButtonType>()
330{
331 return "\"None\", \"Contacts\", \"Credentials\", \"StrongPassword\", \"CreditCard\"";
332}
333
334String convertEnumerationToString(Internals::UserInterfaceLayoutDirection enumerationValue)
335{
336 static const NeverDestroyed<String> values[] = {
337 MAKE_STATIC_STRING_IMPL("LTR"),
338 MAKE_STATIC_STRING_IMPL("RTL"),
339 };
340 static_assert(static_cast<size_t>(Internals::UserInterfaceLayoutDirection::LTR) == 0, "Internals::UserInterfaceLayoutDirection::LTR is not 0 as expected");
341 static_assert(static_cast<size_t>(Internals::UserInterfaceLayoutDirection::RTL) == 1, "Internals::UserInterfaceLayoutDirection::RTL is not 1 as expected");
342 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
343 return values[static_cast<size_t>(enumerationValue)];
344}
345
346template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, Internals::UserInterfaceLayoutDirection enumerationValue)
347{
348 return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue));
349}
350
351template<> std::optional<Internals::UserInterfaceLayoutDirection> parseEnumeration<Internals::UserInterfaceLayoutDirection>(JSGlobalObject& lexicalGlobalObject, JSValue value)
352{
353 auto stringValue = value.toWTFString(&lexicalGlobalObject);
354 if (stringValue == "LTR")
355 return Internals::UserInterfaceLayoutDirection::LTR;
356 if (stringValue == "RTL")
357 return Internals::UserInterfaceLayoutDirection::RTL;
358 return std::nullopt;
359}
360
361template<> const char* expectedEnumerationValues<Internals::UserInterfaceLayoutDirection>()
362{
363 return "\"LTR\", \"RTL\"";
364}
365
366String convertEnumerationToString(Internals::BaseWritingDirection enumerationValue)
367{
368 static const NeverDestroyed<String> values[] = {
369 MAKE_STATIC_STRING_IMPL("Natural"),
370 MAKE_STATIC_STRING_IMPL("Ltr"),
371 MAKE_STATIC_STRING_IMPL("Rtl"),
372 };
373 static_assert(static_cast<size_t>(Internals::BaseWritingDirection::Natural) == 0, "Internals::BaseWritingDirection::Natural is not 0 as expected");
374 static_assert(static_cast<size_t>(Internals::BaseWritingDirection::Ltr) == 1, "Internals::BaseWritingDirection::Ltr is not 1 as expected");
375 static_assert(static_cast<size_t>(Internals::BaseWritingDirection::Rtl) == 2, "Internals::BaseWritingDirection::Rtl is not 2 as expected");
376 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
377 return values[static_cast<size_t>(enumerationValue)];
378}
379
380template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, Internals::BaseWritingDirection enumerationValue)
381{
382 return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue));
383}
384
385template<> std::optional<Internals::BaseWritingDirection> parseEnumeration<Internals::BaseWritingDirection>(JSGlobalObject& lexicalGlobalObject, JSValue value)
386{
387 auto stringValue = value.toWTFString(&lexicalGlobalObject);
388 if (stringValue == "Natural")
389 return Internals::BaseWritingDirection::Natural;
390 if (stringValue == "Ltr")
391 return Internals::BaseWritingDirection::Ltr;
392 if (stringValue == "Rtl")
393 return Internals::BaseWritingDirection::Rtl;
394 return std::nullopt;
395}
396
397template<> const char* expectedEnumerationValues<Internals::BaseWritingDirection>()
398{
399 return "\"Natural\", \"Ltr\", \"Rtl\"";
400}
401
402String convertEnumerationToString(Internals::EventThrottlingBehavior enumerationValue)
403{
404 static const NeverDestroyed<String> values[] = {
405 MAKE_STATIC_STRING_IMPL("responsive"),
406 MAKE_STATIC_STRING_IMPL("unresponsive"),
407 };
408 static_assert(static_cast<size_t>(Internals::EventThrottlingBehavior::Responsive) == 0, "Internals::EventThrottlingBehavior::Responsive is not 0 as expected");
409 static_assert(static_cast<size_t>(Internals::EventThrottlingBehavior::Unresponsive) == 1, "Internals::EventThrottlingBehavior::Unresponsive is not 1 as expected");
410 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
411 return values[static_cast<size_t>(enumerationValue)];
412}
413
414template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, Internals::EventThrottlingBehavior enumerationValue)
415{
416 return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue));
417}
418
419template<> std::optional<Internals::EventThrottlingBehavior> parseEnumeration<Internals::EventThrottlingBehavior>(JSGlobalObject& lexicalGlobalObject, JSValue value)
420{
421 auto stringValue = value.toWTFString(&lexicalGlobalObject);
422 if (stringValue == "responsive")
423 return Internals::EventThrottlingBehavior::Responsive;
424 if (stringValue == "unresponsive")
425 return Internals::EventThrottlingBehavior::Unresponsive;
426 return std::nullopt;
427}
428
429template<> const char* expectedEnumerationValues<Internals::EventThrottlingBehavior>()
430{
431 return "\"responsive\", \"unresponsive\"";
432}
433
434String convertEnumerationToString(Internals::CompositingPolicy enumerationValue)
435{
436 static const NeverDestroyed<String> values[] = {
437 MAKE_STATIC_STRING_IMPL("normal"),
438 MAKE_STATIC_STRING_IMPL("conservative"),
439 };
440 static_assert(static_cast<size_t>(Internals::CompositingPolicy::Normal) == 0, "Internals::CompositingPolicy::Normal is not 0 as expected");
441 static_assert(static_cast<size_t>(Internals::CompositingPolicy::Conservative) == 1, "Internals::CompositingPolicy::Conservative is not 1 as expected");
442 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
443 return values[static_cast<size_t>(enumerationValue)];
444}
445
446template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, Internals::CompositingPolicy enumerationValue)
447{
448 return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue));
449}
450
451template<> std::optional<Internals::CompositingPolicy> parseEnumeration<Internals::CompositingPolicy>(JSGlobalObject& lexicalGlobalObject, JSValue value)
452{
453 auto stringValue = value.toWTFString(&lexicalGlobalObject);
454 if (stringValue == "normal")
455 return Internals::CompositingPolicy::Normal;
456 if (stringValue == "conservative")
457 return Internals::CompositingPolicy::Conservative;
458 return std::nullopt;
459}
460
461template<> const char* expectedEnumerationValues<Internals::CompositingPolicy>()
462{
463 return "\"normal\", \"conservative\"";
464}
465
466#if ENABLE(VIDEO)
467
468String convertEnumerationToString(Internals::PlaybackControlsPurpose enumerationValue)
469{
470 static const NeverDestroyed<String> values[] = {
471 MAKE_STATIC_STRING_IMPL("ControlsManager"),
472 MAKE_STATIC_STRING_IMPL("NowPlaying"),
473 };
474 static_assert(static_cast<size_t>(Internals::PlaybackControlsPurpose::ControlsManager) == 0, "Internals::PlaybackControlsPurpose::ControlsManager is not 0 as expected");
475 static_assert(static_cast<size_t>(Internals::PlaybackControlsPurpose::NowPlaying) == 1, "Internals::PlaybackControlsPurpose::NowPlaying is not 1 as expected");
476 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
477 return values[static_cast<size_t>(enumerationValue)];
478}
479
480template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, Internals::PlaybackControlsPurpose enumerationValue)
481{
482 return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue));
483}
484
485template<> std::optional<Internals::PlaybackControlsPurpose> parseEnumeration<Internals::PlaybackControlsPurpose>(JSGlobalObject& lexicalGlobalObject, JSValue value)
486{
487 auto stringValue = value.toWTFString(&lexicalGlobalObject);
488 if (stringValue == "ControlsManager")
489 return Internals::PlaybackControlsPurpose::ControlsManager;
490 if (stringValue == "NowPlaying")
491 return Internals::PlaybackControlsPurpose::NowPlaying;
492 return std::nullopt;
493}
494
495template<> const char* expectedEnumerationValues<Internals::PlaybackControlsPurpose>()
496{
497 return "\"ControlsManager\", \"NowPlaying\"";
498}
499
500#endif
501
502#if ENABLE(VIDEO)
503
504String convertEnumerationToString(Internals::MediaSessionState enumerationValue)
505{
506 static const NeverDestroyed<String> values[] = {
507 MAKE_STATIC_STRING_IMPL("Idle"),
508 MAKE_STATIC_STRING_IMPL("Autoplaying"),
509 MAKE_STATIC_STRING_IMPL("Playing"),
510 MAKE_STATIC_STRING_IMPL("Paused"),
511 MAKE_STATIC_STRING_IMPL("Interrupted"),
512 };
513 static_assert(static_cast<size_t>(Internals::MediaSessionState::Idle) == 0, "Internals::MediaSessionState::Idle is not 0 as expected");
514 static_assert(static_cast<size_t>(Internals::MediaSessionState::Autoplaying) == 1, "Internals::MediaSessionState::Autoplaying is not 1 as expected");
515 static_assert(static_cast<size_t>(Internals::MediaSessionState::Playing) == 2, "Internals::MediaSessionState::Playing is not 2 as expected");
516 static_assert(static_cast<size_t>(Internals::MediaSessionState::Paused) == 3, "Internals::MediaSessionState::Paused is not 3 as expected");
517 static_assert(static_cast<size_t>(Internals::MediaSessionState::Interrupted) == 4, "Internals::MediaSessionState::Interrupted is not 4 as expected");
518 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
519 return values[static_cast<size_t>(enumerationValue)];
520}
521
522template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, Internals::MediaSessionState enumerationValue)
523{
524 return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue));
525}
526
527template<> std::optional<Internals::MediaSessionState> parseEnumeration<Internals::MediaSessionState>(JSGlobalObject& lexicalGlobalObject, JSValue value)
528{
529 auto stringValue = value.toWTFString(&lexicalGlobalObject);
530 if (stringValue == "Idle")
531 return Internals::MediaSessionState::Idle;
532 if (stringValue == "Autoplaying")
533 return Internals::MediaSessionState::Autoplaying;
534 if (stringValue == "Playing")
535 return Internals::MediaSessionState::Playing;
536 if (stringValue == "Paused")
537 return Internals::MediaSessionState::Paused;
538 if (stringValue == "Interrupted")
539 return Internals::MediaSessionState::Interrupted;
540 return std::nullopt;
541}
542
543template<> const char* expectedEnumerationValues<Internals::MediaSessionState>()
544{
545 return "\"Idle\", \"Autoplaying\", \"Playing\", \"Paused\", \"Interrupted\"";
546}
547
548#endif
549
550String convertEnumerationToString(Internals::ContentSizeCategory enumerationValue)
551{
552 static const NeverDestroyed<String> values[] = {
553 MAKE_STATIC_STRING_IMPL("L"),
554 MAKE_STATIC_STRING_IMPL("XXXL"),
555 };
556 static_assert(static_cast<size_t>(Internals::ContentSizeCategory::L) == 0, "Internals::ContentSizeCategory::L is not 0 as expected");
557 static_assert(static_cast<size_t>(Internals::ContentSizeCategory::XXXL) == 1, "Internals::ContentSizeCategory::XXXL is not 1 as expected");
558 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
559 return values[static_cast<size_t>(enumerationValue)];
560}
561
562template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, Internals::ContentSizeCategory enumerationValue)
563{
564 return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue));
565}
566
567template<> std::optional<Internals::ContentSizeCategory> parseEnumeration<Internals::ContentSizeCategory>(JSGlobalObject& lexicalGlobalObject, JSValue value)
568{
569 auto stringValue = value.toWTFString(&lexicalGlobalObject);
570 if (stringValue == "L")
571 return Internals::ContentSizeCategory::L;
572 if (stringValue == "XXXL")
573 return Internals::ContentSizeCategory::XXXL;
574 return std::nullopt;
575}
576
577template<> const char* expectedEnumerationValues<Internals::ContentSizeCategory>()
578{
579 return "\"L\", \"XXXL\"";
580}
581
582String convertEnumerationToString(Internals::TreeType enumerationValue)
583{
584 static const NeverDestroyed<String> values[] = {
585 MAKE_STATIC_STRING_IMPL("Tree"),
586 MAKE_STATIC_STRING_IMPL("ShadowIncludingTree"),
587 MAKE_STATIC_STRING_IMPL("ComposedTree"),
588 };
589 static_assert(static_cast<size_t>(Internals::TreeType::Tree) == 0, "Internals::TreeType::Tree is not 0 as expected");
590 static_assert(static_cast<size_t>(Internals::TreeType::ShadowIncludingTree) == 1, "Internals::TreeType::ShadowIncludingTree is not 1 as expected");
591 static_assert(static_cast<size_t>(Internals::TreeType::ComposedTree) == 2, "Internals::TreeType::ComposedTree is not 2 as expected");
592 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
593 return values[static_cast<size_t>(enumerationValue)];
594}
595
596template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, Internals::TreeType enumerationValue)
597{
598 return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue));
599}
600
601template<> std::optional<Internals::TreeType> parseEnumeration<Internals::TreeType>(JSGlobalObject& lexicalGlobalObject, JSValue value)
602{
603 auto stringValue = value.toWTFString(&lexicalGlobalObject);
604 if (stringValue == "Tree")
605 return Internals::TreeType::Tree;
606 if (stringValue == "ShadowIncludingTree")
607 return Internals::TreeType::ShadowIncludingTree;
608 if (stringValue == "ComposedTree")
609 return Internals::TreeType::ComposedTree;
610 return std::nullopt;
611}
612
613template<> const char* expectedEnumerationValues<Internals::TreeType>()
614{
615 return "\"Tree\", \"ShadowIncludingTree\", \"ComposedTree\"";
616}
617
618#if ENABLE(WEBGL)
619
620String convertEnumerationToString(Internals::SimulatedWebGLContextEvent enumerationValue)
621{
622 static const NeverDestroyed<String> values[] = {
623 MAKE_STATIC_STRING_IMPL("ContextChange"),
624 MAKE_STATIC_STRING_IMPL("GPUStatusFailure"),
625 MAKE_STATIC_STRING_IMPL("Timeout"),
626 };
627 static_assert(static_cast<size_t>(Internals::SimulatedWebGLContextEvent::ContextChange) == 0, "Internals::SimulatedWebGLContextEvent::ContextChange is not 0 as expected");
628 static_assert(static_cast<size_t>(Internals::SimulatedWebGLContextEvent::GPUStatusFailure) == 1, "Internals::SimulatedWebGLContextEvent::GPUStatusFailure is not 1 as expected");
629 static_assert(static_cast<size_t>(Internals::SimulatedWebGLContextEvent::Timeout) == 2, "Internals::SimulatedWebGLContextEvent::Timeout is not 2 as expected");
630 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
631 return values[static_cast<size_t>(enumerationValue)];
632}
633
634template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, Internals::SimulatedWebGLContextEvent enumerationValue)
635{
636 return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue));
637}
638
639template<> std::optional<Internals::SimulatedWebGLContextEvent> parseEnumeration<Internals::SimulatedWebGLContextEvent>(JSGlobalObject& lexicalGlobalObject, JSValue value)
640{
641 auto stringValue = value.toWTFString(&lexicalGlobalObject);
642 if (stringValue == "ContextChange")
643 return Internals::SimulatedWebGLContextEvent::ContextChange;
644 if (stringValue == "GPUStatusFailure")
645 return Internals::SimulatedWebGLContextEvent::GPUStatusFailure;
646 if (stringValue == "Timeout")
647 return Internals::SimulatedWebGLContextEvent::Timeout;
648 return std::nullopt;
649}
650
651template<> const char* expectedEnumerationValues<Internals::SimulatedWebGLContextEvent>()
652{
653 return "\"ContextChange\", \"GPUStatusFailure\", \"Timeout\"";
654}
655
656#endif
657
658String convertEnumerationToString(Internals::AutoplayPolicy enumerationValue)
659{
660 static const NeverDestroyed<String> values[] = {
661 MAKE_STATIC_STRING_IMPL("Default"),
662 MAKE_STATIC_STRING_IMPL("Allow"),
663 MAKE_STATIC_STRING_IMPL("AllowWithoutSound"),
664 MAKE_STATIC_STRING_IMPL("Deny"),
665 };
666 static_assert(static_cast<size_t>(Internals::AutoplayPolicy::Default) == 0, "Internals::AutoplayPolicy::Default is not 0 as expected");
667 static_assert(static_cast<size_t>(Internals::AutoplayPolicy::Allow) == 1, "Internals::AutoplayPolicy::Allow is not 1 as expected");
668 static_assert(static_cast<size_t>(Internals::AutoplayPolicy::AllowWithoutSound) == 2, "Internals::AutoplayPolicy::AllowWithoutSound is not 2 as expected");
669 static_assert(static_cast<size_t>(Internals::AutoplayPolicy::Deny) == 3, "Internals::AutoplayPolicy::Deny is not 3 as expected");
670 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
671 return values[static_cast<size_t>(enumerationValue)];
672}
673
674template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, Internals::AutoplayPolicy enumerationValue)
675{
676 return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue));
677}
678
679template<> std::optional<Internals::AutoplayPolicy> parseEnumeration<Internals::AutoplayPolicy>(JSGlobalObject& lexicalGlobalObject, JSValue value)
680{
681 auto stringValue = value.toWTFString(&lexicalGlobalObject);
682 if (stringValue == "Default")
683 return Internals::AutoplayPolicy::Default;
684 if (stringValue == "Allow")
685 return Internals::AutoplayPolicy::Allow;
686 if (stringValue == "AllowWithoutSound")
687 return Internals::AutoplayPolicy::AllowWithoutSound;
688 if (stringValue == "Deny")
689 return Internals::AutoplayPolicy::Deny;
690 return std::nullopt;
691}
692
693template<> const char* expectedEnumerationValues<Internals::AutoplayPolicy>()
694{
695 return "\"Default\", \"Allow\", \"AllowWithoutSound\", \"Deny\"";
696}
697
698#if ENABLE(VIDEO)
699
700template<> Internals::NowPlayingState convertDictionary<Internals::NowPlayingState>(JSGlobalObject& lexicalGlobalObject, JSValue value)
701{
702 VM& vm = JSC::getVM(&lexicalGlobalObject);
703 auto throwScope = DECLARE_THROW_SCOPE(vm);
704 bool isNullOrUndefined = value.isUndefinedOrNull();
705 auto* object = isNullOrUndefined ? nullptr : value.getObject();
706 if (UNLIKELY(!isNullOrUndefined && !object)) {
707 throwTypeError(&lexicalGlobalObject, throwScope);
708 return { };
709 }
710 Internals::NowPlayingState result;
711 JSValue durationValue;
712 if (isNullOrUndefined)
713 durationValue = jsUndefined();
714 else {
715 durationValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "duration"));
716 RETURN_IF_EXCEPTION(throwScope, { });
717 }
718 if (!durationValue.isUndefined()) {
719 result.duration = convert<IDLUnrestrictedDouble>(lexicalGlobalObject, durationValue);
720 RETURN_IF_EXCEPTION(throwScope, { });
721 }
722 JSValue elapsedTimeValue;
723 if (isNullOrUndefined)
724 elapsedTimeValue = jsUndefined();
725 else {
726 elapsedTimeValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "elapsedTime"));
727 RETURN_IF_EXCEPTION(throwScope, { });
728 }
729 if (!elapsedTimeValue.isUndefined()) {
730 result.elapsedTime = convert<IDLUnrestrictedDouble>(lexicalGlobalObject, elapsedTimeValue);
731 RETURN_IF_EXCEPTION(throwScope, { });
732 }
733 JSValue hasActiveSessionValue;
734 if (isNullOrUndefined)
735 hasActiveSessionValue = jsUndefined();
736 else {
737 hasActiveSessionValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "hasActiveSession"));
738 RETURN_IF_EXCEPTION(throwScope, { });
739 }
740 if (!hasActiveSessionValue.isUndefined()) {
741 result.hasActiveSession = convert<IDLBoolean>(lexicalGlobalObject, hasActiveSessionValue);
742 RETURN_IF_EXCEPTION(throwScope, { });
743 }
744 JSValue haveEverRegisteredAsNowPlayingApplicationValue;
745 if (isNullOrUndefined)
746 haveEverRegisteredAsNowPlayingApplicationValue = jsUndefined();
747 else {
748 haveEverRegisteredAsNowPlayingApplicationValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "haveEverRegisteredAsNowPlayingApplication"));
749 RETURN_IF_EXCEPTION(throwScope, { });
750 }
751 if (!haveEverRegisteredAsNowPlayingApplicationValue.isUndefined()) {
752 result.haveEverRegisteredAsNowPlayingApplication = convert<IDLBoolean>(lexicalGlobalObject, haveEverRegisteredAsNowPlayingApplicationValue);
753 RETURN_IF_EXCEPTION(throwScope, { });
754 }
755 JSValue registeredAsNowPlayingApplicationValue;
756 if (isNullOrUndefined)
757 registeredAsNowPlayingApplicationValue = jsUndefined();
758 else {
759 registeredAsNowPlayingApplicationValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "registeredAsNowPlayingApplication"));
760 RETURN_IF_EXCEPTION(throwScope, { });
761 }
762 if (!registeredAsNowPlayingApplicationValue.isUndefined()) {
763 result.registeredAsNowPlayingApplication = convert<IDLBoolean>(lexicalGlobalObject, registeredAsNowPlayingApplicationValue);
764 RETURN_IF_EXCEPTION(throwScope, { });
765 }
766 JSValue titleValue;
767 if (isNullOrUndefined)
768 titleValue = jsUndefined();
769 else {
770 titleValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "title"));
771 RETURN_IF_EXCEPTION(throwScope, { });
772 }
773 if (!titleValue.isUndefined()) {
774 result.title = convert<IDLDOMString>(lexicalGlobalObject, titleValue);
775 RETURN_IF_EXCEPTION(throwScope, { });
776 }
777 JSValue uniqueIdentifierValue;
778 if (isNullOrUndefined)
779 uniqueIdentifierValue = jsUndefined();
780 else {
781 uniqueIdentifierValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "uniqueIdentifier"));
782 RETURN_IF_EXCEPTION(throwScope, { });
783 }
784 if (!uniqueIdentifierValue.isUndefined()) {
785 result.uniqueIdentifier = convert<IDLUnsignedLongLong>(lexicalGlobalObject, uniqueIdentifierValue);
786 RETURN_IF_EXCEPTION(throwScope, { });
787 }
788 return result;
789}
790
791JSC::JSObject* convertDictionaryToJS(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject, const Internals::NowPlayingState& dictionary)
792{
793 auto& vm = JSC::getVM(&lexicalGlobalObject);
794 auto throwScope = DECLARE_THROW_SCOPE(vm);
795
796 auto result = constructEmptyObject(&lexicalGlobalObject, globalObject.objectPrototype());
797
798 if (!IDLUnrestrictedDouble::isNullValue(dictionary.duration)) {
799 auto durationValue = toJS<IDLUnrestrictedDouble>(lexicalGlobalObject, throwScope, IDLUnrestrictedDouble::extractValueFromNullable(dictionary.duration));
800 RETURN_IF_EXCEPTION(throwScope, { });
801 result->putDirect(vm, JSC::Identifier::fromString(vm, "duration"), durationValue);
802 }
803 if (!IDLUnrestrictedDouble::isNullValue(dictionary.elapsedTime)) {
804 auto elapsedTimeValue = toJS<IDLUnrestrictedDouble>(lexicalGlobalObject, throwScope, IDLUnrestrictedDouble::extractValueFromNullable(dictionary.elapsedTime));
805 RETURN_IF_EXCEPTION(throwScope, { });
806 result->putDirect(vm, JSC::Identifier::fromString(vm, "elapsedTime"), elapsedTimeValue);
807 }
808 if (!IDLBoolean::isNullValue(dictionary.hasActiveSession)) {
809 auto hasActiveSessionValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.hasActiveSession));
810 RETURN_IF_EXCEPTION(throwScope, { });
811 result->putDirect(vm, JSC::Identifier::fromString(vm, "hasActiveSession"), hasActiveSessionValue);
812 }
813 if (!IDLBoolean::isNullValue(dictionary.haveEverRegisteredAsNowPlayingApplication)) {
814 auto haveEverRegisteredAsNowPlayingApplicationValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.haveEverRegisteredAsNowPlayingApplication));
815 RETURN_IF_EXCEPTION(throwScope, { });
816 result->putDirect(vm, JSC::Identifier::fromString(vm, "haveEverRegisteredAsNowPlayingApplication"), haveEverRegisteredAsNowPlayingApplicationValue);
817 }
818 if (!IDLBoolean::isNullValue(dictionary.registeredAsNowPlayingApplication)) {
819 auto registeredAsNowPlayingApplicationValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.registeredAsNowPlayingApplication));
820 RETURN_IF_EXCEPTION(throwScope, { });
821 result->putDirect(vm, JSC::Identifier::fromString(vm, "registeredAsNowPlayingApplication"), registeredAsNowPlayingApplicationValue);
822 }
823 if (!IDLDOMString::isNullValue(dictionary.title)) {
824 auto titleValue = toJS<IDLDOMString>(lexicalGlobalObject, throwScope, IDLDOMString::extractValueFromNullable(dictionary.title));
825 RETURN_IF_EXCEPTION(throwScope, { });
826 result->putDirect(vm, JSC::Identifier::fromString(vm, "title"), titleValue);
827 }
828 if (!IDLUnsignedLongLong::isNullValue(dictionary.uniqueIdentifier)) {
829 auto uniqueIdentifierValue = toJS<IDLUnsignedLongLong>(lexicalGlobalObject, throwScope, IDLUnsignedLongLong::extractValueFromNullable(dictionary.uniqueIdentifier));
830 RETURN_IF_EXCEPTION(throwScope, { });
831 result->putDirect(vm, JSC::Identifier::fromString(vm, "uniqueIdentifier"), uniqueIdentifierValue);
832 }
833 return result;
834}
835
836#endif
837
838#if ENABLE(VIDEO)
839
840template<> Internals::MediaUsageState convertDictionary<Internals::MediaUsageState>(JSGlobalObject& lexicalGlobalObject, JSValue value)
841{
842 VM& vm = JSC::getVM(&lexicalGlobalObject);
843 auto throwScope = DECLARE_THROW_SCOPE(vm);
844 bool isNullOrUndefined = value.isUndefinedOrNull();
845 auto* object = isNullOrUndefined ? nullptr : value.getObject();
846 if (UNLIKELY(!isNullOrUndefined && !object)) {
847 throwTypeError(&lexicalGlobalObject, throwScope);
848 return { };
849 }
850 Internals::MediaUsageState result;
851 JSValue audioElementWithUserGestureValue;
852 if (isNullOrUndefined)
853 audioElementWithUserGestureValue = jsUndefined();
854 else {
855 audioElementWithUserGestureValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "audioElementWithUserGesture"));
856 RETURN_IF_EXCEPTION(throwScope, { });
857 }
858 if (!audioElementWithUserGestureValue.isUndefined()) {
859 result.audioElementWithUserGesture = convert<IDLBoolean>(lexicalGlobalObject, audioElementWithUserGestureValue);
860 RETURN_IF_EXCEPTION(throwScope, { });
861 }
862 JSValue canShowControlsManagerValue;
863 if (isNullOrUndefined)
864 canShowControlsManagerValue = jsUndefined();
865 else {
866 canShowControlsManagerValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "canShowControlsManager"));
867 RETURN_IF_EXCEPTION(throwScope, { });
868 }
869 if (!canShowControlsManagerValue.isUndefined()) {
870 result.canShowControlsManager = convert<IDLBoolean>(lexicalGlobalObject, canShowControlsManagerValue);
871 RETURN_IF_EXCEPTION(throwScope, { });
872 }
873 JSValue canShowNowPlayingControlsValue;
874 if (isNullOrUndefined)
875 canShowNowPlayingControlsValue = jsUndefined();
876 else {
877 canShowNowPlayingControlsValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "canShowNowPlayingControls"));
878 RETURN_IF_EXCEPTION(throwScope, { });
879 }
880 if (!canShowNowPlayingControlsValue.isUndefined()) {
881 result.canShowNowPlayingControls = convert<IDLBoolean>(lexicalGlobalObject, canShowNowPlayingControlsValue);
882 RETURN_IF_EXCEPTION(throwScope, { });
883 }
884 JSValue hasAudioValue;
885 if (isNullOrUndefined)
886 hasAudioValue = jsUndefined();
887 else {
888 hasAudioValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "hasAudio"));
889 RETURN_IF_EXCEPTION(throwScope, { });
890 }
891 if (!hasAudioValue.isUndefined()) {
892 result.hasAudio = convert<IDLBoolean>(lexicalGlobalObject, hasAudioValue);
893 RETURN_IF_EXCEPTION(throwScope, { });
894 }
895 JSValue hasEverNotifiedAboutPlayingValue;
896 if (isNullOrUndefined)
897 hasEverNotifiedAboutPlayingValue = jsUndefined();
898 else {
899 hasEverNotifiedAboutPlayingValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "hasEverNotifiedAboutPlaying"));
900 RETURN_IF_EXCEPTION(throwScope, { });
901 }
902 if (!hasEverNotifiedAboutPlayingValue.isUndefined()) {
903 result.hasEverNotifiedAboutPlaying = convert<IDLBoolean>(lexicalGlobalObject, hasEverNotifiedAboutPlayingValue);
904 RETURN_IF_EXCEPTION(throwScope, { });
905 }
906 JSValue hasHadUserInteractionAndQuirksContainsShouldAutoplayForArbitraryUserGestureValue;
907 if (isNullOrUndefined)
908 hasHadUserInteractionAndQuirksContainsShouldAutoplayForArbitraryUserGestureValue = jsUndefined();
909 else {
910 hasHadUserInteractionAndQuirksContainsShouldAutoplayForArbitraryUserGestureValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "hasHadUserInteractionAndQuirksContainsShouldAutoplayForArbitraryUserGesture"));
911 RETURN_IF_EXCEPTION(throwScope, { });
912 }
913 if (!hasHadUserInteractionAndQuirksContainsShouldAutoplayForArbitraryUserGestureValue.isUndefined()) {
914 result.hasHadUserInteractionAndQuirksContainsShouldAutoplayForArbitraryUserGesture = convert<IDLBoolean>(lexicalGlobalObject, hasHadUserInteractionAndQuirksContainsShouldAutoplayForArbitraryUserGestureValue);
915 RETURN_IF_EXCEPTION(throwScope, { });
916 }
917 JSValue hasRendererValue;
918 if (isNullOrUndefined)
919 hasRendererValue = jsUndefined();
920 else {
921 hasRendererValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "hasRenderer"));
922 RETURN_IF_EXCEPTION(throwScope, { });
923 }
924 if (!hasRendererValue.isUndefined()) {
925 result.hasRenderer = convert<IDLBoolean>(lexicalGlobalObject, hasRendererValue);
926 RETURN_IF_EXCEPTION(throwScope, { });
927 }
928 JSValue hasVideoValue;
929 if (isNullOrUndefined)
930 hasVideoValue = jsUndefined();
931 else {
932 hasVideoValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "hasVideo"));
933 RETURN_IF_EXCEPTION(throwScope, { });
934 }
935 if (!hasVideoValue.isUndefined()) {
936 result.hasVideo = convert<IDLBoolean>(lexicalGlobalObject, hasVideoValue);
937 RETURN_IF_EXCEPTION(throwScope, { });
938 }
939 JSValue isAudioValue;
940 if (isNullOrUndefined)
941 isAudioValue = jsUndefined();
942 else {
943 isAudioValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isAudio"));
944 RETURN_IF_EXCEPTION(throwScope, { });
945 }
946 if (!isAudioValue.isUndefined()) {
947 result.isAudio = convert<IDLBoolean>(lexicalGlobalObject, isAudioValue);
948 RETURN_IF_EXCEPTION(throwScope, { });
949 }
950 JSValue isAudioAndRequiresUserGestureForAudioRateChangeValue;
951 if (isNullOrUndefined)
952 isAudioAndRequiresUserGestureForAudioRateChangeValue = jsUndefined();
953 else {
954 isAudioAndRequiresUserGestureForAudioRateChangeValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isAudioAndRequiresUserGestureForAudioRateChange"));
955 RETURN_IF_EXCEPTION(throwScope, { });
956 }
957 if (!isAudioAndRequiresUserGestureForAudioRateChangeValue.isUndefined()) {
958 result.isAudioAndRequiresUserGestureForAudioRateChange = convert<IDLBoolean>(lexicalGlobalObject, isAudioAndRequiresUserGestureForAudioRateChangeValue);
959 RETURN_IF_EXCEPTION(throwScope, { });
960 }
961 JSValue isElementRectMostlyInMainFrameValue;
962 if (isNullOrUndefined)
963 isElementRectMostlyInMainFrameValue = jsUndefined();
964 else {
965 isElementRectMostlyInMainFrameValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isElementRectMostlyInMainFrame"));
966 RETURN_IF_EXCEPTION(throwScope, { });
967 }
968 if (!isElementRectMostlyInMainFrameValue.isUndefined()) {
969 result.isElementRectMostlyInMainFrame = convert<IDLBoolean>(lexicalGlobalObject, isElementRectMostlyInMainFrameValue);
970 RETURN_IF_EXCEPTION(throwScope, { });
971 }
972 JSValue isFullscreenValue;
973 if (isNullOrUndefined)
974 isFullscreenValue = jsUndefined();
975 else {
976 isFullscreenValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isFullscreen"));
977 RETURN_IF_EXCEPTION(throwScope, { });
978 }
979 if (!isFullscreenValue.isUndefined()) {
980 result.isFullscreen = convert<IDLBoolean>(lexicalGlobalObject, isFullscreenValue);
981 RETURN_IF_EXCEPTION(throwScope, { });
982 }
983 JSValue isInActiveDocumentValue;
984 if (isNullOrUndefined)
985 isInActiveDocumentValue = jsUndefined();
986 else {
987 isInActiveDocumentValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isInActiveDocument"));
988 RETURN_IF_EXCEPTION(throwScope, { });
989 }
990 if (!isInActiveDocumentValue.isUndefined()) {
991 result.isInActiveDocument = convert<IDLBoolean>(lexicalGlobalObject, isInActiveDocumentValue);
992 RETURN_IF_EXCEPTION(throwScope, { });
993 }
994 JSValue isLargeEnoughForMainContentValue;
995 if (isNullOrUndefined)
996 isLargeEnoughForMainContentValue = jsUndefined();
997 else {
998 isLargeEnoughForMainContentValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isLargeEnoughForMainContent"));
999 RETURN_IF_EXCEPTION(throwScope, { });
1000 }
1001 if (!isLargeEnoughForMainContentValue.isUndefined()) {
1002 result.isLargeEnoughForMainContent = convert<IDLBoolean>(lexicalGlobalObject, isLargeEnoughForMainContentValue);
1003 RETURN_IF_EXCEPTION(throwScope, { });
1004 }
1005 JSValue isMediaDocumentAndNotOwnerElementValue;
1006 if (isNullOrUndefined)
1007 isMediaDocumentAndNotOwnerElementValue = jsUndefined();
1008 else {
1009 isMediaDocumentAndNotOwnerElementValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isMediaDocumentAndNotOwnerElement"));
1010 RETURN_IF_EXCEPTION(throwScope, { });
1011 }
1012 if (!isMediaDocumentAndNotOwnerElementValue.isUndefined()) {
1013 result.isMediaDocumentAndNotOwnerElement = convert<IDLBoolean>(lexicalGlobalObject, isMediaDocumentAndNotOwnerElementValue);
1014 RETURN_IF_EXCEPTION(throwScope, { });
1015 }
1016 JSValue isMediaDocumentInMainFrameValue;
1017 if (isNullOrUndefined)
1018 isMediaDocumentInMainFrameValue = jsUndefined();
1019 else {
1020 isMediaDocumentInMainFrameValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isMediaDocumentInMainFrame"));
1021 RETURN_IF_EXCEPTION(throwScope, { });
1022 }
1023 if (!isMediaDocumentInMainFrameValue.isUndefined()) {
1024 result.isMediaDocumentInMainFrame = convert<IDLBoolean>(lexicalGlobalObject, isMediaDocumentInMainFrameValue);
1025 RETURN_IF_EXCEPTION(throwScope, { });
1026 }
1027 JSValue isMutedValue;
1028 if (isNullOrUndefined)
1029 isMutedValue = jsUndefined();
1030 else {
1031 isMutedValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isMuted"));
1032 RETURN_IF_EXCEPTION(throwScope, { });
1033 }
1034 if (!isMutedValue.isUndefined()) {
1035 result.isMuted = convert<IDLBoolean>(lexicalGlobalObject, isMutedValue);
1036 RETURN_IF_EXCEPTION(throwScope, { });
1037 }
1038 JSValue isPlayingValue;
1039 if (isNullOrUndefined)
1040 isPlayingValue = jsUndefined();
1041 else {
1042 isPlayingValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isPlaying"));
1043 RETURN_IF_EXCEPTION(throwScope, { });
1044 }
1045 if (!isPlayingValue.isUndefined()) {
1046 result.isPlaying = convert<IDLBoolean>(lexicalGlobalObject, isPlayingValue);
1047 RETURN_IF_EXCEPTION(throwScope, { });
1048 }
1049 JSValue isSuspendedValue;
1050 if (isNullOrUndefined)
1051 isSuspendedValue = jsUndefined();
1052 else {
1053 isSuspendedValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isSuspended"));
1054 RETURN_IF_EXCEPTION(throwScope, { });
1055 }
1056 if (!isSuspendedValue.isUndefined()) {
1057 result.isSuspended = convert<IDLBoolean>(lexicalGlobalObject, isSuspendedValue);
1058 RETURN_IF_EXCEPTION(throwScope, { });
1059 }
1060 JSValue isVideoValue;
1061 if (isNullOrUndefined)
1062 isVideoValue = jsUndefined();
1063 else {
1064 isVideoValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isVideo"));
1065 RETURN_IF_EXCEPTION(throwScope, { });
1066 }
1067 if (!isVideoValue.isUndefined()) {
1068 result.isVideo = convert<IDLBoolean>(lexicalGlobalObject, isVideoValue);
1069 RETURN_IF_EXCEPTION(throwScope, { });
1070 }
1071 JSValue isVideoAndRequiresUserGestureForVideoDueToLowPowerModeValue;
1072 if (isNullOrUndefined)
1073 isVideoAndRequiresUserGestureForVideoDueToLowPowerModeValue = jsUndefined();
1074 else {
1075 isVideoAndRequiresUserGestureForVideoDueToLowPowerModeValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isVideoAndRequiresUserGestureForVideoDueToLowPowerMode"));
1076 RETURN_IF_EXCEPTION(throwScope, { });
1077 }
1078 if (!isVideoAndRequiresUserGestureForVideoDueToLowPowerModeValue.isUndefined()) {
1079 result.isVideoAndRequiresUserGestureForVideoDueToLowPowerMode = convert<IDLBoolean>(lexicalGlobalObject, isVideoAndRequiresUserGestureForVideoDueToLowPowerModeValue);
1080 RETURN_IF_EXCEPTION(throwScope, { });
1081 }
1082 JSValue isVideoAndRequiresUserGestureForVideoRateChangeValue;
1083 if (isNullOrUndefined)
1084 isVideoAndRequiresUserGestureForVideoRateChangeValue = jsUndefined();
1085 else {
1086 isVideoAndRequiresUserGestureForVideoRateChangeValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isVideoAndRequiresUserGestureForVideoRateChange"));
1087 RETURN_IF_EXCEPTION(throwScope, { });
1088 }
1089 if (!isVideoAndRequiresUserGestureForVideoRateChangeValue.isUndefined()) {
1090 result.isVideoAndRequiresUserGestureForVideoRateChange = convert<IDLBoolean>(lexicalGlobalObject, isVideoAndRequiresUserGestureForVideoRateChangeValue);
1091 RETURN_IF_EXCEPTION(throwScope, { });
1092 }
1093 JSValue mediaURLValue;
1094 if (isNullOrUndefined)
1095 mediaURLValue = jsUndefined();
1096 else {
1097 mediaURLValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "mediaURL"));
1098 RETURN_IF_EXCEPTION(throwScope, { });
1099 }
1100 if (!mediaURLValue.isUndefined()) {
1101 result.mediaURL = convert<IDLDOMString>(lexicalGlobalObject, mediaURLValue);
1102 RETURN_IF_EXCEPTION(throwScope, { });
1103 }
1104 JSValue noUserGestureRequiredValue;
1105 if (isNullOrUndefined)
1106 noUserGestureRequiredValue = jsUndefined();
1107 else {
1108 noUserGestureRequiredValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "noUserGestureRequired"));
1109 RETURN_IF_EXCEPTION(throwScope, { });
1110 }
1111 if (!noUserGestureRequiredValue.isUndefined()) {
1112 result.noUserGestureRequired = convert<IDLBoolean>(lexicalGlobalObject, noUserGestureRequiredValue);
1113 RETURN_IF_EXCEPTION(throwScope, { });
1114 }
1115 JSValue outsideOfFullscreenValue;
1116 if (isNullOrUndefined)
1117 outsideOfFullscreenValue = jsUndefined();
1118 else {
1119 outsideOfFullscreenValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "outsideOfFullscreen"));
1120 RETURN_IF_EXCEPTION(throwScope, { });
1121 }
1122 if (!outsideOfFullscreenValue.isUndefined()) {
1123 result.outsideOfFullscreen = convert<IDLBoolean>(lexicalGlobalObject, outsideOfFullscreenValue);
1124 RETURN_IF_EXCEPTION(throwScope, { });
1125 }
1126 JSValue pageExplicitlyAllowsElementToAutoplayInlineValue;
1127 if (isNullOrUndefined)
1128 pageExplicitlyAllowsElementToAutoplayInlineValue = jsUndefined();
1129 else {
1130 pageExplicitlyAllowsElementToAutoplayInlineValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "pageExplicitlyAllowsElementToAutoplayInline"));
1131 RETURN_IF_EXCEPTION(throwScope, { });
1132 }
1133 if (!pageExplicitlyAllowsElementToAutoplayInlineValue.isUndefined()) {
1134 result.pageExplicitlyAllowsElementToAutoplayInline = convert<IDLBoolean>(lexicalGlobalObject, pageExplicitlyAllowsElementToAutoplayInlineValue);
1135 RETURN_IF_EXCEPTION(throwScope, { });
1136 }
1137 JSValue pageMediaPlaybackSuspendedValue;
1138 if (isNullOrUndefined)
1139 pageMediaPlaybackSuspendedValue = jsUndefined();
1140 else {
1141 pageMediaPlaybackSuspendedValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "pageMediaPlaybackSuspended"));
1142 RETURN_IF_EXCEPTION(throwScope, { });
1143 }
1144 if (!pageMediaPlaybackSuspendedValue.isUndefined()) {
1145 result.pageMediaPlaybackSuspended = convert<IDLBoolean>(lexicalGlobalObject, pageMediaPlaybackSuspendedValue);
1146 RETURN_IF_EXCEPTION(throwScope, { });
1147 }
1148 JSValue playbackPermittedValue;
1149 if (isNullOrUndefined)
1150 playbackPermittedValue = jsUndefined();
1151 else {
1152 playbackPermittedValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "playbackPermitted"));
1153 RETURN_IF_EXCEPTION(throwScope, { });
1154 }
1155 if (!playbackPermittedValue.isUndefined()) {
1156 result.playbackPermitted = convert<IDLBoolean>(lexicalGlobalObject, playbackPermittedValue);
1157 RETURN_IF_EXCEPTION(throwScope, { });
1158 }
1159 JSValue requiresFullscreenForVideoPlaybackAndFullscreenNotPermittedValue;
1160 if (isNullOrUndefined)
1161 requiresFullscreenForVideoPlaybackAndFullscreenNotPermittedValue = jsUndefined();
1162 else {
1163 requiresFullscreenForVideoPlaybackAndFullscreenNotPermittedValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "requiresFullscreenForVideoPlaybackAndFullscreenNotPermitted"));
1164 RETURN_IF_EXCEPTION(throwScope, { });
1165 }
1166 if (!requiresFullscreenForVideoPlaybackAndFullscreenNotPermittedValue.isUndefined()) {
1167 result.requiresFullscreenForVideoPlaybackAndFullscreenNotPermitted = convert<IDLBoolean>(lexicalGlobalObject, requiresFullscreenForVideoPlaybackAndFullscreenNotPermittedValue);
1168 RETURN_IF_EXCEPTION(throwScope, { });
1169 }
1170 JSValue requiresPlaybackAndIsNotPlayingValue;
1171 if (isNullOrUndefined)
1172 requiresPlaybackAndIsNotPlayingValue = jsUndefined();
1173 else {
1174 requiresPlaybackAndIsNotPlayingValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "requiresPlaybackAndIsNotPlaying"));
1175 RETURN_IF_EXCEPTION(throwScope, { });
1176 }
1177 if (!requiresPlaybackAndIsNotPlayingValue.isUndefined()) {
1178 result.requiresPlaybackAndIsNotPlaying = convert<IDLBoolean>(lexicalGlobalObject, requiresPlaybackAndIsNotPlayingValue);
1179 RETURN_IF_EXCEPTION(throwScope, { });
1180 }
1181 JSValue userHasPlayedAudioBeforeValue;
1182 if (isNullOrUndefined)
1183 userHasPlayedAudioBeforeValue = jsUndefined();
1184 else {
1185 userHasPlayedAudioBeforeValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "userHasPlayedAudioBefore"));
1186 RETURN_IF_EXCEPTION(throwScope, { });
1187 }
1188 if (!userHasPlayedAudioBeforeValue.isUndefined()) {
1189 result.userHasPlayedAudioBefore = convert<IDLBoolean>(lexicalGlobalObject, userHasPlayedAudioBeforeValue);
1190 RETURN_IF_EXCEPTION(throwScope, { });
1191 }
1192 return result;
1193}
1194
1195JSC::JSObject* convertDictionaryToJS(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject, const Internals::MediaUsageState& dictionary)
1196{
1197 auto& vm = JSC::getVM(&lexicalGlobalObject);
1198 auto throwScope = DECLARE_THROW_SCOPE(vm);
1199
1200 auto result = constructEmptyObject(&lexicalGlobalObject, globalObject.objectPrototype());
1201
1202 if (!IDLBoolean::isNullValue(dictionary.audioElementWithUserGesture)) {
1203 auto audioElementWithUserGestureValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.audioElementWithUserGesture));
1204 RETURN_IF_EXCEPTION(throwScope, { });
1205 result->putDirect(vm, JSC::Identifier::fromString(vm, "audioElementWithUserGesture"), audioElementWithUserGestureValue);
1206 }
1207 if (!IDLBoolean::isNullValue(dictionary.canShowControlsManager)) {
1208 auto canShowControlsManagerValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.canShowControlsManager));
1209 RETURN_IF_EXCEPTION(throwScope, { });
1210 result->putDirect(vm, JSC::Identifier::fromString(vm, "canShowControlsManager"), canShowControlsManagerValue);
1211 }
1212 if (!IDLBoolean::isNullValue(dictionary.canShowNowPlayingControls)) {
1213 auto canShowNowPlayingControlsValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.canShowNowPlayingControls));
1214 RETURN_IF_EXCEPTION(throwScope, { });
1215 result->putDirect(vm, JSC::Identifier::fromString(vm, "canShowNowPlayingControls"), canShowNowPlayingControlsValue);
1216 }
1217 if (!IDLBoolean::isNullValue(dictionary.hasAudio)) {
1218 auto hasAudioValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.hasAudio));
1219 RETURN_IF_EXCEPTION(throwScope, { });
1220 result->putDirect(vm, JSC::Identifier::fromString(vm, "hasAudio"), hasAudioValue);
1221 }
1222 if (!IDLBoolean::isNullValue(dictionary.hasEverNotifiedAboutPlaying)) {
1223 auto hasEverNotifiedAboutPlayingValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.hasEverNotifiedAboutPlaying));
1224 RETURN_IF_EXCEPTION(throwScope, { });
1225 result->putDirect(vm, JSC::Identifier::fromString(vm, "hasEverNotifiedAboutPlaying"), hasEverNotifiedAboutPlayingValue);
1226 }
1227 if (!IDLBoolean::isNullValue(dictionary.hasHadUserInteractionAndQuirksContainsShouldAutoplayForArbitraryUserGesture)) {
1228 auto hasHadUserInteractionAndQuirksContainsShouldAutoplayForArbitraryUserGestureValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.hasHadUserInteractionAndQuirksContainsShouldAutoplayForArbitraryUserGesture));
1229 RETURN_IF_EXCEPTION(throwScope, { });
1230 result->putDirect(vm, JSC::Identifier::fromString(vm, "hasHadUserInteractionAndQuirksContainsShouldAutoplayForArbitraryUserGesture"), hasHadUserInteractionAndQuirksContainsShouldAutoplayForArbitraryUserGestureValue);
1231 }
1232 if (!IDLBoolean::isNullValue(dictionary.hasRenderer)) {
1233 auto hasRendererValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.hasRenderer));
1234 RETURN_IF_EXCEPTION(throwScope, { });
1235 result->putDirect(vm, JSC::Identifier::fromString(vm, "hasRenderer"), hasRendererValue);
1236 }
1237 if (!IDLBoolean::isNullValue(dictionary.hasVideo)) {
1238 auto hasVideoValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.hasVideo));
1239 RETURN_IF_EXCEPTION(throwScope, { });
1240 result->putDirect(vm, JSC::Identifier::fromString(vm, "hasVideo"), hasVideoValue);
1241 }
1242 if (!IDLBoolean::isNullValue(dictionary.isAudio)) {
1243 auto isAudioValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isAudio));
1244 RETURN_IF_EXCEPTION(throwScope, { });
1245 result->putDirect(vm, JSC::Identifier::fromString(vm, "isAudio"), isAudioValue);
1246 }
1247 if (!IDLBoolean::isNullValue(dictionary.isAudioAndRequiresUserGestureForAudioRateChange)) {
1248 auto isAudioAndRequiresUserGestureForAudioRateChangeValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isAudioAndRequiresUserGestureForAudioRateChange));
1249 RETURN_IF_EXCEPTION(throwScope, { });
1250 result->putDirect(vm, JSC::Identifier::fromString(vm, "isAudioAndRequiresUserGestureForAudioRateChange"), isAudioAndRequiresUserGestureForAudioRateChangeValue);
1251 }
1252 if (!IDLBoolean::isNullValue(dictionary.isElementRectMostlyInMainFrame)) {
1253 auto isElementRectMostlyInMainFrameValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isElementRectMostlyInMainFrame));
1254 RETURN_IF_EXCEPTION(throwScope, { });
1255 result->putDirect(vm, JSC::Identifier::fromString(vm, "isElementRectMostlyInMainFrame"), isElementRectMostlyInMainFrameValue);
1256 }
1257 if (!IDLBoolean::isNullValue(dictionary.isFullscreen)) {
1258 auto isFullscreenValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isFullscreen));
1259 RETURN_IF_EXCEPTION(throwScope, { });
1260 result->putDirect(vm, JSC::Identifier::fromString(vm, "isFullscreen"), isFullscreenValue);
1261 }
1262 if (!IDLBoolean::isNullValue(dictionary.isInActiveDocument)) {
1263 auto isInActiveDocumentValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isInActiveDocument));
1264 RETURN_IF_EXCEPTION(throwScope, { });
1265 result->putDirect(vm, JSC::Identifier::fromString(vm, "isInActiveDocument"), isInActiveDocumentValue);
1266 }
1267 if (!IDLBoolean::isNullValue(dictionary.isLargeEnoughForMainContent)) {
1268 auto isLargeEnoughForMainContentValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isLargeEnoughForMainContent));
1269 RETURN_IF_EXCEPTION(throwScope, { });
1270 result->putDirect(vm, JSC::Identifier::fromString(vm, "isLargeEnoughForMainContent"), isLargeEnoughForMainContentValue);
1271 }
1272 if (!IDLBoolean::isNullValue(dictionary.isMediaDocumentAndNotOwnerElement)) {
1273 auto isMediaDocumentAndNotOwnerElementValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isMediaDocumentAndNotOwnerElement));
1274 RETURN_IF_EXCEPTION(throwScope, { });
1275 result->putDirect(vm, JSC::Identifier::fromString(vm, "isMediaDocumentAndNotOwnerElement"), isMediaDocumentAndNotOwnerElementValue);
1276 }
1277 if (!IDLBoolean::isNullValue(dictionary.isMediaDocumentInMainFrame)) {
1278 auto isMediaDocumentInMainFrameValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isMediaDocumentInMainFrame));
1279 RETURN_IF_EXCEPTION(throwScope, { });
1280 result->putDirect(vm, JSC::Identifier::fromString(vm, "isMediaDocumentInMainFrame"), isMediaDocumentInMainFrameValue);
1281 }
1282 if (!IDLBoolean::isNullValue(dictionary.isMuted)) {
1283 auto isMutedValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isMuted));
1284 RETURN_IF_EXCEPTION(throwScope, { });
1285 result->putDirect(vm, JSC::Identifier::fromString(vm, "isMuted"), isMutedValue);
1286 }
1287 if (!IDLBoolean::isNullValue(dictionary.isPlaying)) {
1288 auto isPlayingValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isPlaying));
1289 RETURN_IF_EXCEPTION(throwScope, { });
1290 result->putDirect(vm, JSC::Identifier::fromString(vm, "isPlaying"), isPlayingValue);
1291 }
1292 if (!IDLBoolean::isNullValue(dictionary.isSuspended)) {
1293 auto isSuspendedValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isSuspended));
1294 RETURN_IF_EXCEPTION(throwScope, { });
1295 result->putDirect(vm, JSC::Identifier::fromString(vm, "isSuspended"), isSuspendedValue);
1296 }
1297 if (!IDLBoolean::isNullValue(dictionary.isVideo)) {
1298 auto isVideoValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isVideo));
1299 RETURN_IF_EXCEPTION(throwScope, { });
1300 result->putDirect(vm, JSC::Identifier::fromString(vm, "isVideo"), isVideoValue);
1301 }
1302 if (!IDLBoolean::isNullValue(dictionary.isVideoAndRequiresUserGestureForVideoDueToLowPowerMode)) {
1303 auto isVideoAndRequiresUserGestureForVideoDueToLowPowerModeValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isVideoAndRequiresUserGestureForVideoDueToLowPowerMode));
1304 RETURN_IF_EXCEPTION(throwScope, { });
1305 result->putDirect(vm, JSC::Identifier::fromString(vm, "isVideoAndRequiresUserGestureForVideoDueToLowPowerMode"), isVideoAndRequiresUserGestureForVideoDueToLowPowerModeValue);
1306 }
1307 if (!IDLBoolean::isNullValue(dictionary.isVideoAndRequiresUserGestureForVideoRateChange)) {
1308 auto isVideoAndRequiresUserGestureForVideoRateChangeValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isVideoAndRequiresUserGestureForVideoRateChange));
1309 RETURN_IF_EXCEPTION(throwScope, { });
1310 result->putDirect(vm, JSC::Identifier::fromString(vm, "isVideoAndRequiresUserGestureForVideoRateChange"), isVideoAndRequiresUserGestureForVideoRateChangeValue);
1311 }
1312 if (!IDLDOMString::isNullValue(dictionary.mediaURL)) {
1313 auto mediaURLValue = toJS<IDLDOMString>(lexicalGlobalObject, throwScope, IDLDOMString::extractValueFromNullable(dictionary.mediaURL));
1314 RETURN_IF_EXCEPTION(throwScope, { });
1315 result->putDirect(vm, JSC::Identifier::fromString(vm, "mediaURL"), mediaURLValue);
1316 }
1317 if (!IDLBoolean::isNullValue(dictionary.noUserGestureRequired)) {
1318 auto noUserGestureRequiredValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.noUserGestureRequired));
1319 RETURN_IF_EXCEPTION(throwScope, { });
1320 result->putDirect(vm, JSC::Identifier::fromString(vm, "noUserGestureRequired"), noUserGestureRequiredValue);
1321 }
1322 if (!IDLBoolean::isNullValue(dictionary.outsideOfFullscreen)) {
1323 auto outsideOfFullscreenValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.outsideOfFullscreen));
1324 RETURN_IF_EXCEPTION(throwScope, { });
1325 result->putDirect(vm, JSC::Identifier::fromString(vm, "outsideOfFullscreen"), outsideOfFullscreenValue);
1326 }
1327 if (!IDLBoolean::isNullValue(dictionary.pageExplicitlyAllowsElementToAutoplayInline)) {
1328 auto pageExplicitlyAllowsElementToAutoplayInlineValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.pageExplicitlyAllowsElementToAutoplayInline));
1329 RETURN_IF_EXCEPTION(throwScope, { });
1330 result->putDirect(vm, JSC::Identifier::fromString(vm, "pageExplicitlyAllowsElementToAutoplayInline"), pageExplicitlyAllowsElementToAutoplayInlineValue);
1331 }
1332 if (!IDLBoolean::isNullValue(dictionary.pageMediaPlaybackSuspended)) {
1333 auto pageMediaPlaybackSuspendedValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.pageMediaPlaybackSuspended));
1334 RETURN_IF_EXCEPTION(throwScope, { });
1335 result->putDirect(vm, JSC::Identifier::fromString(vm, "pageMediaPlaybackSuspended"), pageMediaPlaybackSuspendedValue);
1336 }
1337 if (!IDLBoolean::isNullValue(dictionary.playbackPermitted)) {
1338 auto playbackPermittedValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.playbackPermitted));
1339 RETURN_IF_EXCEPTION(throwScope, { });
1340 result->putDirect(vm, JSC::Identifier::fromString(vm, "playbackPermitted"), playbackPermittedValue);
1341 }
1342 if (!IDLBoolean::isNullValue(dictionary.requiresFullscreenForVideoPlaybackAndFullscreenNotPermitted)) {
1343 auto requiresFullscreenForVideoPlaybackAndFullscreenNotPermittedValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.requiresFullscreenForVideoPlaybackAndFullscreenNotPermitted));
1344 RETURN_IF_EXCEPTION(throwScope, { });
1345 result->putDirect(vm, JSC::Identifier::fromString(vm, "requiresFullscreenForVideoPlaybackAndFullscreenNotPermitted"), requiresFullscreenForVideoPlaybackAndFullscreenNotPermittedValue);
1346 }
1347 if (!IDLBoolean::isNullValue(dictionary.requiresPlaybackAndIsNotPlaying)) {
1348 auto requiresPlaybackAndIsNotPlayingValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.requiresPlaybackAndIsNotPlaying));
1349 RETURN_IF_EXCEPTION(throwScope, { });
1350 result->putDirect(vm, JSC::Identifier::fromString(vm, "requiresPlaybackAndIsNotPlaying"), requiresPlaybackAndIsNotPlayingValue);
1351 }
1352 if (!IDLBoolean::isNullValue(dictionary.userHasPlayedAudioBefore)) {
1353 auto userHasPlayedAudioBeforeValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.userHasPlayedAudioBefore));
1354 RETURN_IF_EXCEPTION(throwScope, { });
1355 result->putDirect(vm, JSC::Identifier::fromString(vm, "userHasPlayedAudioBefore"), userHasPlayedAudioBeforeValue);
1356 }
1357 return result;
1358}
1359
1360#endif
1361
1362template<> Internals::FullscreenInsets convertDictionary<Internals::FullscreenInsets>(JSGlobalObject& lexicalGlobalObject, JSValue value)
1363{
1364 VM& vm = JSC::getVM(&lexicalGlobalObject);
1365 auto throwScope = DECLARE_THROW_SCOPE(vm);
1366 bool isNullOrUndefined = value.isUndefinedOrNull();
1367 auto* object = isNullOrUndefined ? nullptr : value.getObject();
1368 if (UNLIKELY(!isNullOrUndefined && !object)) {
1369 throwTypeError(&lexicalGlobalObject, throwScope);
1370 return { };
1371 }
1372 Internals::FullscreenInsets result;
1373 JSValue bottomValue;
1374 if (isNullOrUndefined)
1375 bottomValue = jsUndefined();
1376 else {
1377 bottomValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "bottom"));
1378 RETURN_IF_EXCEPTION(throwScope, { });
1379 }
1380 if (!bottomValue.isUndefined()) {
1381 result.bottom = convert<IDLDouble>(lexicalGlobalObject, bottomValue);
1382 RETURN_IF_EXCEPTION(throwScope, { });
1383 }
1384 JSValue leftValue;
1385 if (isNullOrUndefined)
1386 leftValue = jsUndefined();
1387 else {
1388 leftValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "left"));
1389 RETURN_IF_EXCEPTION(throwScope, { });
1390 }
1391 if (!leftValue.isUndefined()) {
1392 result.left = convert<IDLDouble>(lexicalGlobalObject, leftValue);
1393 RETURN_IF_EXCEPTION(throwScope, { });
1394 }
1395 JSValue rightValue;
1396 if (isNullOrUndefined)
1397 rightValue = jsUndefined();
1398 else {
1399 rightValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "right"));
1400 RETURN_IF_EXCEPTION(throwScope, { });
1401 }
1402 if (!rightValue.isUndefined()) {
1403 result.right = convert<IDLDouble>(lexicalGlobalObject, rightValue);
1404 RETURN_IF_EXCEPTION(throwScope, { });
1405 }
1406 JSValue topValue;
1407 if (isNullOrUndefined)
1408 topValue = jsUndefined();
1409 else {
1410 topValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "top"));
1411 RETURN_IF_EXCEPTION(throwScope, { });
1412 }
1413 if (!topValue.isUndefined()) {
1414 result.top = convert<IDLDouble>(lexicalGlobalObject, topValue);
1415 RETURN_IF_EXCEPTION(throwScope, { });
1416 }
1417 return result;
1418}
1419
1420JSC::JSObject* convertDictionaryToJS(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject, const Internals::FullscreenInsets& dictionary)
1421{
1422 auto& vm = JSC::getVM(&lexicalGlobalObject);
1423 auto throwScope = DECLARE_THROW_SCOPE(vm);
1424
1425 auto result = constructEmptyObject(&lexicalGlobalObject, globalObject.objectPrototype());
1426
1427 if (!IDLDouble::isNullValue(dictionary.bottom)) {
1428 auto bottomValue = toJS<IDLDouble>(lexicalGlobalObject, throwScope, IDLDouble::extractValueFromNullable(dictionary.bottom));
1429 RETURN_IF_EXCEPTION(throwScope, { });
1430 result->putDirect(vm, JSC::Identifier::fromString(vm, "bottom"), bottomValue);
1431 }
1432 if (!IDLDouble::isNullValue(dictionary.left)) {
1433 auto leftValue = toJS<IDLDouble>(lexicalGlobalObject, throwScope, IDLDouble::extractValueFromNullable(dictionary.left));
1434 RETURN_IF_EXCEPTION(throwScope, { });
1435 result->putDirect(vm, JSC::Identifier::fromString(vm, "left"), leftValue);
1436 }
1437 if (!IDLDouble::isNullValue(dictionary.right)) {
1438 auto rightValue = toJS<IDLDouble>(lexicalGlobalObject, throwScope, IDLDouble::extractValueFromNullable(dictionary.right));
1439 RETURN_IF_EXCEPTION(throwScope, { });
1440 result->putDirect(vm, JSC::Identifier::fromString(vm, "right"), rightValue);
1441 }
1442 if (!IDLDouble::isNullValue(dictionary.top)) {
1443 auto topValue = toJS<IDLDouble>(lexicalGlobalObject, throwScope, IDLDouble::extractValueFromNullable(dictionary.top));
1444 RETURN_IF_EXCEPTION(throwScope, { });
1445 result->putDirect(vm, JSC::Identifier::fromString(vm, "top"), topValue);
1446 }
1447 return result;
1448}
1449
1450template<> Internals::HEVCParameterSet convertDictionary<Internals::HEVCParameterSet>(JSGlobalObject& lexicalGlobalObject, JSValue value)
1451{
1452 VM& vm = JSC::getVM(&lexicalGlobalObject);
1453 auto throwScope = DECLARE_THROW_SCOPE(vm);
1454 bool isNullOrUndefined = value.isUndefinedOrNull();
1455 auto* object = isNullOrUndefined ? nullptr : value.getObject();
1456 if (UNLIKELY(!isNullOrUndefined && !object)) {
1457 throwTypeError(&lexicalGlobalObject, throwScope);
1458 return { };
1459 }
1460 Internals::HEVCParameterSet result;
1461 JSValue generalLevelIDCValue;
1462 if (isNullOrUndefined)
1463 generalLevelIDCValue = jsUndefined();
1464 else {
1465 generalLevelIDCValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "generalLevelIDC"));
1466 RETURN_IF_EXCEPTION(throwScope, { });
1467 }
1468 if (!generalLevelIDCValue.isUndefined()) {
1469 result.generalLevelIDC = convert<IDLUnsignedShort>(lexicalGlobalObject, generalLevelIDCValue);
1470 RETURN_IF_EXCEPTION(throwScope, { });
1471 }
1472 JSValue generalProfileCompatibilityFlagsValue;
1473 if (isNullOrUndefined)
1474 generalProfileCompatibilityFlagsValue = jsUndefined();
1475 else {
1476 generalProfileCompatibilityFlagsValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "generalProfileCompatibilityFlags"));
1477 RETURN_IF_EXCEPTION(throwScope, { });
1478 }
1479 if (!generalProfileCompatibilityFlagsValue.isUndefined()) {
1480 result.generalProfileCompatibilityFlags = convert<IDLUnsignedLong>(lexicalGlobalObject, generalProfileCompatibilityFlagsValue);
1481 RETURN_IF_EXCEPTION(throwScope, { });
1482 }
1483 JSValue generalProfileIDCValue;
1484 if (isNullOrUndefined)
1485 generalProfileIDCValue = jsUndefined();
1486 else {
1487 generalProfileIDCValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "generalProfileIDC"));
1488 RETURN_IF_EXCEPTION(throwScope, { });
1489 }
1490 if (!generalProfileIDCValue.isUndefined()) {
1491 result.generalProfileIDC = convert<IDLUnsignedShort>(lexicalGlobalObject, generalProfileIDCValue);
1492 RETURN_IF_EXCEPTION(throwScope, { });
1493 }
1494 JSValue generalProfileSpaceValue;
1495 if (isNullOrUndefined)
1496 generalProfileSpaceValue = jsUndefined();
1497 else {
1498 generalProfileSpaceValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "generalProfileSpace"));
1499 RETURN_IF_EXCEPTION(throwScope, { });
1500 }
1501 if (!generalProfileSpaceValue.isUndefined()) {
1502 result.generalProfileSpace = convert<IDLUnsignedShort>(lexicalGlobalObject, generalProfileSpaceValue);
1503 RETURN_IF_EXCEPTION(throwScope, { });
1504 }
1505 return result;
1506}
1507
1508JSC::JSObject* convertDictionaryToJS(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject, const Internals::HEVCParameterSet& dictionary)
1509{
1510 auto& vm = JSC::getVM(&lexicalGlobalObject);
1511 auto throwScope = DECLARE_THROW_SCOPE(vm);
1512
1513 auto result = constructEmptyObject(&lexicalGlobalObject, globalObject.objectPrototype());
1514
1515 if (!IDLUnsignedShort::isNullValue(dictionary.generalLevelIDC)) {
1516 auto generalLevelIDCValue = toJS<IDLUnsignedShort>(lexicalGlobalObject, throwScope, IDLUnsignedShort::extractValueFromNullable(dictionary.generalLevelIDC));
1517 RETURN_IF_EXCEPTION(throwScope, { });
1518 result->putDirect(vm, JSC::Identifier::fromString(vm, "generalLevelIDC"), generalLevelIDCValue);
1519 }
1520 if (!IDLUnsignedLong::isNullValue(dictionary.generalProfileCompatibilityFlags)) {
1521 auto generalProfileCompatibilityFlagsValue = toJS<IDLUnsignedLong>(lexicalGlobalObject, throwScope, IDLUnsignedLong::extractValueFromNullable(dictionary.generalProfileCompatibilityFlags));
1522 RETURN_IF_EXCEPTION(throwScope, { });
1523 result->putDirect(vm, JSC::Identifier::fromString(vm, "generalProfileCompatibilityFlags"), generalProfileCompatibilityFlagsValue);
1524 }
1525 if (!IDLUnsignedShort::isNullValue(dictionary.generalProfileIDC)) {
1526 auto generalProfileIDCValue = toJS<IDLUnsignedShort>(lexicalGlobalObject, throwScope, IDLUnsignedShort::extractValueFromNullable(dictionary.generalProfileIDC));
1527 RETURN_IF_EXCEPTION(throwScope, { });
1528 result->putDirect(vm, JSC::Identifier::fromString(vm, "generalProfileIDC"), generalProfileIDCValue);
1529 }
1530 if (!IDLUnsignedShort::isNullValue(dictionary.generalProfileSpace)) {
1531 auto generalProfileSpaceValue = toJS<IDLUnsignedShort>(lexicalGlobalObject, throwScope, IDLUnsignedShort::extractValueFromNullable(dictionary.generalProfileSpace));
1532 RETURN_IF_EXCEPTION(throwScope, { });
1533 result->putDirect(vm, JSC::Identifier::fromString(vm, "generalProfileSpace"), generalProfileSpaceValue);
1534 }
1535 return result;
1536}
1537
1538template<> Internals::DoViParameterSet convertDictionary<Internals::DoViParameterSet>(JSGlobalObject& lexicalGlobalObject, JSValue value)
1539{
1540 VM& vm = JSC::getVM(&lexicalGlobalObject);
1541 auto throwScope = DECLARE_THROW_SCOPE(vm);
1542 bool isNullOrUndefined = value.isUndefinedOrNull();
1543 auto* object = isNullOrUndefined ? nullptr : value.getObject();
1544 if (UNLIKELY(!isNullOrUndefined && !object)) {
1545 throwTypeError(&lexicalGlobalObject, throwScope);
1546 return { };
1547 }
1548 Internals::DoViParameterSet result;
1549 JSValue bitstreamLevelIDValue;
1550 if (isNullOrUndefined)
1551 bitstreamLevelIDValue = jsUndefined();
1552 else {
1553 bitstreamLevelIDValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "bitstreamLevelID"));
1554 RETURN_IF_EXCEPTION(throwScope, { });
1555 }
1556 if (!bitstreamLevelIDValue.isUndefined()) {
1557 result.bitstreamLevelID = convert<IDLUnsignedShort>(lexicalGlobalObject, bitstreamLevelIDValue);
1558 RETURN_IF_EXCEPTION(throwScope, { });
1559 }
1560 JSValue bitstreamProfileIDValue;
1561 if (isNullOrUndefined)
1562 bitstreamProfileIDValue = jsUndefined();
1563 else {
1564 bitstreamProfileIDValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "bitstreamProfileID"));
1565 RETURN_IF_EXCEPTION(throwScope, { });
1566 }
1567 if (!bitstreamProfileIDValue.isUndefined()) {
1568 result.bitstreamProfileID = convert<IDLUnsignedShort>(lexicalGlobalObject, bitstreamProfileIDValue);
1569 RETURN_IF_EXCEPTION(throwScope, { });
1570 }
1571 JSValue codecNameValue;
1572 if (isNullOrUndefined)
1573 codecNameValue = jsUndefined();
1574 else {
1575 codecNameValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "codecName"));
1576 RETURN_IF_EXCEPTION(throwScope, { });
1577 }
1578 if (!codecNameValue.isUndefined()) {
1579 result.codecName = convert<IDLDOMString>(lexicalGlobalObject, codecNameValue);
1580 RETURN_IF_EXCEPTION(throwScope, { });
1581 }
1582 return result;
1583}
1584
1585JSC::JSObject* convertDictionaryToJS(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject, const Internals::DoViParameterSet& dictionary)
1586{
1587 auto& vm = JSC::getVM(&lexicalGlobalObject);
1588 auto throwScope = DECLARE_THROW_SCOPE(vm);
1589
1590 auto result = constructEmptyObject(&lexicalGlobalObject, globalObject.objectPrototype());
1591
1592 if (!IDLUnsignedShort::isNullValue(dictionary.bitstreamLevelID)) {
1593 auto bitstreamLevelIDValue = toJS<IDLUnsignedShort>(lexicalGlobalObject, throwScope, IDLUnsignedShort::extractValueFromNullable(dictionary.bitstreamLevelID));
1594 RETURN_IF_EXCEPTION(throwScope, { });
1595 result->putDirect(vm, JSC::Identifier::fromString(vm, "bitstreamLevelID"), bitstreamLevelIDValue);
1596 }
1597 if (!IDLUnsignedShort::isNullValue(dictionary.bitstreamProfileID)) {
1598 auto bitstreamProfileIDValue = toJS<IDLUnsignedShort>(lexicalGlobalObject, throwScope, IDLUnsignedShort::extractValueFromNullable(dictionary.bitstreamProfileID));
1599 RETURN_IF_EXCEPTION(throwScope, { });
1600 result->putDirect(vm, JSC::Identifier::fromString(vm, "bitstreamProfileID"), bitstreamProfileIDValue);
1601 }
1602 if (!IDLDOMString::isNullValue(dictionary.codecName)) {
1603 auto codecNameValue = toJS<IDLDOMString>(lexicalGlobalObject, throwScope, IDLDOMString::extractValueFromNullable(dictionary.codecName));
1604 RETURN_IF_EXCEPTION(throwScope, { });
1605 result->putDirect(vm, JSC::Identifier::fromString(vm, "codecName"), codecNameValue);
1606 }
1607 return result;
1608}
1609
1610template<> Internals::VPCodecConfigurationRecord convertDictionary<Internals::VPCodecConfigurationRecord>(JSGlobalObject& lexicalGlobalObject, JSValue value)
1611{
1612 VM& vm = JSC::getVM(&lexicalGlobalObject);
1613 auto throwScope = DECLARE_THROW_SCOPE(vm);
1614 bool isNullOrUndefined = value.isUndefinedOrNull();
1615 auto* object = isNullOrUndefined ? nullptr : value.getObject();
1616 if (UNLIKELY(!isNullOrUndefined && !object)) {
1617 throwTypeError(&lexicalGlobalObject, throwScope);
1618 return { };
1619 }
1620 Internals::VPCodecConfigurationRecord result;
1621 JSValue bitDepthValue;
1622 if (isNullOrUndefined)
1623 bitDepthValue = jsUndefined();
1624 else {
1625 bitDepthValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "bitDepth"));
1626 RETURN_IF_EXCEPTION(throwScope, { });
1627 }
1628 if (!bitDepthValue.isUndefined()) {
1629 result.bitDepth = convert<IDLOctet>(lexicalGlobalObject, bitDepthValue);
1630 RETURN_IF_EXCEPTION(throwScope, { });
1631 }
1632 JSValue chromaSubsamplingValue;
1633 if (isNullOrUndefined)
1634 chromaSubsamplingValue = jsUndefined();
1635 else {
1636 chromaSubsamplingValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "chromaSubsampling"));
1637 RETURN_IF_EXCEPTION(throwScope, { });
1638 }
1639 if (!chromaSubsamplingValue.isUndefined()) {
1640 result.chromaSubsampling = convert<IDLOctet>(lexicalGlobalObject, chromaSubsamplingValue);
1641 RETURN_IF_EXCEPTION(throwScope, { });
1642 }
1643 JSValue codecNameValue;
1644 if (isNullOrUndefined)
1645 codecNameValue = jsUndefined();
1646 else {
1647 codecNameValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "codecName"));
1648 RETURN_IF_EXCEPTION(throwScope, { });
1649 }
1650 if (!codecNameValue.isUndefined()) {
1651 result.codecName = convert<IDLDOMString>(lexicalGlobalObject, codecNameValue);
1652 RETURN_IF_EXCEPTION(throwScope, { });
1653 }
1654 JSValue colorPrimariesValue;
1655 if (isNullOrUndefined)
1656 colorPrimariesValue = jsUndefined();
1657 else {
1658 colorPrimariesValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "colorPrimaries"));
1659 RETURN_IF_EXCEPTION(throwScope, { });
1660 }
1661 if (!colorPrimariesValue.isUndefined()) {
1662 result.colorPrimaries = convert<IDLOctet>(lexicalGlobalObject, colorPrimariesValue);
1663 RETURN_IF_EXCEPTION(throwScope, { });
1664 }
1665 JSValue levelValue;
1666 if (isNullOrUndefined)
1667 levelValue = jsUndefined();
1668 else {
1669 levelValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "level"));
1670 RETURN_IF_EXCEPTION(throwScope, { });
1671 }
1672 if (!levelValue.isUndefined()) {
1673 result.level = convert<IDLOctet>(lexicalGlobalObject, levelValue);
1674 RETURN_IF_EXCEPTION(throwScope, { });
1675 }
1676 JSValue matrixCoefficientsValue;
1677 if (isNullOrUndefined)
1678 matrixCoefficientsValue = jsUndefined();
1679 else {
1680 matrixCoefficientsValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "matrixCoefficients"));
1681 RETURN_IF_EXCEPTION(throwScope, { });
1682 }
1683 if (!matrixCoefficientsValue.isUndefined()) {
1684 result.matrixCoefficients = convert<IDLOctet>(lexicalGlobalObject, matrixCoefficientsValue);
1685 RETURN_IF_EXCEPTION(throwScope, { });
1686 }
1687 JSValue profileValue;
1688 if (isNullOrUndefined)
1689 profileValue = jsUndefined();
1690 else {
1691 profileValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "profile"));
1692 RETURN_IF_EXCEPTION(throwScope, { });
1693 }
1694 if (!profileValue.isUndefined()) {
1695 result.profile = convert<IDLOctet>(lexicalGlobalObject, profileValue);
1696 RETURN_IF_EXCEPTION(throwScope, { });
1697 }
1698 JSValue transferCharacteristicsValue;
1699 if (isNullOrUndefined)
1700 transferCharacteristicsValue = jsUndefined();
1701 else {
1702 transferCharacteristicsValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "transferCharacteristics"));
1703 RETURN_IF_EXCEPTION(throwScope, { });
1704 }
1705 if (!transferCharacteristicsValue.isUndefined()) {
1706 result.transferCharacteristics = convert<IDLOctet>(lexicalGlobalObject, transferCharacteristicsValue);
1707 RETURN_IF_EXCEPTION(throwScope, { });
1708 }
1709 JSValue videoFullRangeFlagValue;
1710 if (isNullOrUndefined)
1711 videoFullRangeFlagValue = jsUndefined();
1712 else {
1713 videoFullRangeFlagValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "videoFullRangeFlag"));
1714 RETURN_IF_EXCEPTION(throwScope, { });
1715 }
1716 if (!videoFullRangeFlagValue.isUndefined()) {
1717 result.videoFullRangeFlag = convert<IDLOctet>(lexicalGlobalObject, videoFullRangeFlagValue);
1718 RETURN_IF_EXCEPTION(throwScope, { });
1719 }
1720 return result;
1721}
1722
1723JSC::JSObject* convertDictionaryToJS(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject, const Internals::VPCodecConfigurationRecord& dictionary)
1724{
1725 auto& vm = JSC::getVM(&lexicalGlobalObject);
1726 auto throwScope = DECLARE_THROW_SCOPE(vm);
1727
1728 auto result = constructEmptyObject(&lexicalGlobalObject, globalObject.objectPrototype());
1729
1730 if (!IDLOctet::isNullValue(dictionary.bitDepth)) {
1731 auto bitDepthValue = toJS<IDLOctet>(lexicalGlobalObject, throwScope, IDLOctet::extractValueFromNullable(dictionary.bitDepth));
1732 RETURN_IF_EXCEPTION(throwScope, { });
1733 result->putDirect(vm, JSC::Identifier::fromString(vm, "bitDepth"), bitDepthValue);
1734 }
1735 if (!IDLOctet::isNullValue(dictionary.chromaSubsampling)) {
1736 auto chromaSubsamplingValue = toJS<IDLOctet>(lexicalGlobalObject, throwScope, IDLOctet::extractValueFromNullable(dictionary.chromaSubsampling));
1737 RETURN_IF_EXCEPTION(throwScope, { });
1738 result->putDirect(vm, JSC::Identifier::fromString(vm, "chromaSubsampling"), chromaSubsamplingValue);
1739 }
1740 if (!IDLDOMString::isNullValue(dictionary.codecName)) {
1741 auto codecNameValue = toJS<IDLDOMString>(lexicalGlobalObject, throwScope, IDLDOMString::extractValueFromNullable(dictionary.codecName));
1742 RETURN_IF_EXCEPTION(throwScope, { });
1743 result->putDirect(vm, JSC::Identifier::fromString(vm, "codecName"), codecNameValue);
1744 }
1745 if (!IDLOctet::isNullValue(dictionary.colorPrimaries)) {
1746 auto colorPrimariesValue = toJS<IDLOctet>(lexicalGlobalObject, throwScope, IDLOctet::extractValueFromNullable(dictionary.colorPrimaries));
1747 RETURN_IF_EXCEPTION(throwScope, { });
1748 result->putDirect(vm, JSC::Identifier::fromString(vm, "colorPrimaries"), colorPrimariesValue);
1749 }
1750 if (!IDLOctet::isNullValue(dictionary.level)) {
1751 auto levelValue = toJS<IDLOctet>(lexicalGlobalObject, throwScope, IDLOctet::extractValueFromNullable(dictionary.level));
1752 RETURN_IF_EXCEPTION(throwScope, { });
1753 result->putDirect(vm, JSC::Identifier::fromString(vm, "level"), levelValue);
1754 }
1755 if (!IDLOctet::isNullValue(dictionary.matrixCoefficients)) {
1756 auto matrixCoefficientsValue = toJS<IDLOctet>(lexicalGlobalObject, throwScope, IDLOctet::extractValueFromNullable(dictionary.matrixCoefficients));
1757 RETURN_IF_EXCEPTION(throwScope, { });
1758 result->putDirect(vm, JSC::Identifier::fromString(vm, "matrixCoefficients"), matrixCoefficientsValue);
1759 }
1760 if (!IDLOctet::isNullValue(dictionary.profile)) {
1761 auto profileValue = toJS<IDLOctet>(lexicalGlobalObject, throwScope, IDLOctet::extractValueFromNullable(dictionary.profile));
1762 RETURN_IF_EXCEPTION(throwScope, { });
1763 result->putDirect(vm, JSC::Identifier::fromString(vm, "profile"), profileValue);
1764 }
1765 if (!IDLOctet::isNullValue(dictionary.transferCharacteristics)) {
1766 auto transferCharacteristicsValue = toJS<IDLOctet>(lexicalGlobalObject, throwScope, IDLOctet::extractValueFromNullable(dictionary.transferCharacteristics));
1767 RETURN_IF_EXCEPTION(throwScope, { });
1768 result->putDirect(vm, JSC::Identifier::fromString(vm, "transferCharacteristics"), transferCharacteristicsValue);
1769 }
1770 if (!IDLOctet::isNullValue(dictionary.videoFullRangeFlag)) {
1771 auto videoFullRangeFlagValue = toJS<IDLOctet>(lexicalGlobalObject, throwScope, IDLOctet::extractValueFromNullable(dictionary.videoFullRangeFlag));
1772 RETURN_IF_EXCEPTION(throwScope, { });
1773 result->putDirect(vm, JSC::Identifier::fromString(vm, "videoFullRangeFlag"), videoFullRangeFlagValue);
1774 }
1775 return result;
1776}
1777
1778template<> Internals::AcceleratedAnimation convertDictionary<Internals::AcceleratedAnimation>(JSGlobalObject& lexicalGlobalObject, JSValue value)
1779{
1780 VM& vm = JSC::getVM(&lexicalGlobalObject);
1781 auto throwScope = DECLARE_THROW_SCOPE(vm);
1782 bool isNullOrUndefined = value.isUndefinedOrNull();
1783 auto* object = isNullOrUndefined ? nullptr : value.getObject();
1784 if (UNLIKELY(!isNullOrUndefined && !object)) {
1785 throwTypeError(&lexicalGlobalObject, throwScope);
1786 return { };
1787 }
1788 Internals::AcceleratedAnimation result;
1789 JSValue propertyValue;
1790 if (isNullOrUndefined)
1791 propertyValue = jsUndefined();
1792 else {
1793 propertyValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "property"));
1794 RETURN_IF_EXCEPTION(throwScope, { });
1795 }
1796 if (!propertyValue.isUndefined()) {
1797 result.property = convert<IDLDOMString>(lexicalGlobalObject, propertyValue);
1798 RETURN_IF_EXCEPTION(throwScope, { });
1799 }
1800 JSValue speedValue;
1801 if (isNullOrUndefined)
1802 speedValue = jsUndefined();
1803 else {
1804 speedValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "speed"));
1805 RETURN_IF_EXCEPTION(throwScope, { });
1806 }
1807 if (!speedValue.isUndefined()) {
1808 result.speed = convert<IDLDouble>(lexicalGlobalObject, speedValue);
1809 RETURN_IF_EXCEPTION(throwScope, { });
1810 }
1811 return result;
1812}
1813
1814JSC::JSObject* convertDictionaryToJS(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject, const Internals::AcceleratedAnimation& dictionary)
1815{
1816 auto& vm = JSC::getVM(&lexicalGlobalObject);
1817 auto throwScope = DECLARE_THROW_SCOPE(vm);
1818
1819 auto result = constructEmptyObject(&lexicalGlobalObject, globalObject.objectPrototype());
1820
1821 if (!IDLDOMString::isNullValue(dictionary.property)) {
1822 auto propertyValue = toJS<IDLDOMString>(lexicalGlobalObject, throwScope, IDLDOMString::extractValueFromNullable(dictionary.property));
1823 RETURN_IF_EXCEPTION(throwScope, { });
1824 result->putDirect(vm, JSC::Identifier::fromString(vm, "property"), propertyValue);
1825 }
1826 if (!IDLDouble::isNullValue(dictionary.speed)) {
1827 auto speedValue = toJS<IDLDouble>(lexicalGlobalObject, throwScope, IDLDouble::extractValueFromNullable(dictionary.speed));
1828 RETURN_IF_EXCEPTION(throwScope, { });
1829 result->putDirect(vm, JSC::Identifier::fromString(vm, "speed"), speedValue);
1830 }
1831 return result;
1832}
1833
1834template<> Internals::CookieData convertDictionary<Internals::CookieData>(JSGlobalObject& lexicalGlobalObject, JSValue value)
1835{
1836 VM& vm = JSC::getVM(&lexicalGlobalObject);
1837 auto throwScope = DECLARE_THROW_SCOPE(vm);
1838 bool isNullOrUndefined = value.isUndefinedOrNull();
1839 auto* object = isNullOrUndefined ? nullptr : value.getObject();
1840 if (UNLIKELY(!isNullOrUndefined && !object)) {
1841 throwTypeError(&lexicalGlobalObject, throwScope);
1842 return { };
1843 }
1844 Internals::CookieData result;
1845 JSValue domainValue;
1846 if (isNullOrUndefined)
1847 domainValue = jsUndefined();
1848 else {
1849 domainValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "domain"));
1850 RETURN_IF_EXCEPTION(throwScope, { });
1851 }
1852 if (!domainValue.isUndefined()) {
1853 result.domain = convert<IDLDOMString>(lexicalGlobalObject, domainValue);
1854 RETURN_IF_EXCEPTION(throwScope, { });
1855 }
1856 JSValue expiresValue;
1857 if (isNullOrUndefined)
1858 expiresValue = jsUndefined();
1859 else {
1860 expiresValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "expires"));
1861 RETURN_IF_EXCEPTION(throwScope, { });
1862 }
1863 if (!expiresValue.isUndefined()) {
1864 result.expires = convert<IDLDouble>(lexicalGlobalObject, expiresValue);
1865 RETURN_IF_EXCEPTION(throwScope, { });
1866 }
1867 JSValue isHttpOnlyValue;
1868 if (isNullOrUndefined)
1869 isHttpOnlyValue = jsUndefined();
1870 else {
1871 isHttpOnlyValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isHttpOnly"));
1872 RETURN_IF_EXCEPTION(throwScope, { });
1873 }
1874 if (!isHttpOnlyValue.isUndefined()) {
1875 result.isHttpOnly = convert<IDLBoolean>(lexicalGlobalObject, isHttpOnlyValue);
1876 RETURN_IF_EXCEPTION(throwScope, { });
1877 }
1878 JSValue isSameSiteLaxValue;
1879 if (isNullOrUndefined)
1880 isSameSiteLaxValue = jsUndefined();
1881 else {
1882 isSameSiteLaxValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isSameSiteLax"));
1883 RETURN_IF_EXCEPTION(throwScope, { });
1884 }
1885 if (!isSameSiteLaxValue.isUndefined()) {
1886 result.isSameSiteLax = convert<IDLBoolean>(lexicalGlobalObject, isSameSiteLaxValue);
1887 RETURN_IF_EXCEPTION(throwScope, { });
1888 }
1889 JSValue isSameSiteStrictValue;
1890 if (isNullOrUndefined)
1891 isSameSiteStrictValue = jsUndefined();
1892 else {
1893 isSameSiteStrictValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isSameSiteStrict"));
1894 RETURN_IF_EXCEPTION(throwScope, { });
1895 }
1896 if (!isSameSiteStrictValue.isUndefined()) {
1897 result.isSameSiteStrict = convert<IDLBoolean>(lexicalGlobalObject, isSameSiteStrictValue);
1898 RETURN_IF_EXCEPTION(throwScope, { });
1899 }
1900 JSValue isSecureValue;
1901 if (isNullOrUndefined)
1902 isSecureValue = jsUndefined();
1903 else {
1904 isSecureValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isSecure"));
1905 RETURN_IF_EXCEPTION(throwScope, { });
1906 }
1907 if (!isSecureValue.isUndefined()) {
1908 result.isSecure = convert<IDLBoolean>(lexicalGlobalObject, isSecureValue);
1909 RETURN_IF_EXCEPTION(throwScope, { });
1910 }
1911 JSValue isSessionValue;
1912 if (isNullOrUndefined)
1913 isSessionValue = jsUndefined();
1914 else {
1915 isSessionValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "isSession"));
1916 RETURN_IF_EXCEPTION(throwScope, { });
1917 }
1918 if (!isSessionValue.isUndefined()) {
1919 result.isSession = convert<IDLBoolean>(lexicalGlobalObject, isSessionValue);
1920 RETURN_IF_EXCEPTION(throwScope, { });
1921 }
1922 JSValue nameValue;
1923 if (isNullOrUndefined)
1924 nameValue = jsUndefined();
1925 else {
1926 nameValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "name"));
1927 RETURN_IF_EXCEPTION(throwScope, { });
1928 }
1929 if (!nameValue.isUndefined()) {
1930 result.name = convert<IDLDOMString>(lexicalGlobalObject, nameValue);
1931 RETURN_IF_EXCEPTION(throwScope, { });
1932 }
1933 JSValue valueValue;
1934 if (isNullOrUndefined)
1935 valueValue = jsUndefined();
1936 else {
1937 valueValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "value"));
1938 RETURN_IF_EXCEPTION(throwScope, { });
1939 }
1940 if (!valueValue.isUndefined()) {
1941 result.value = convert<IDLDOMString>(lexicalGlobalObject, valueValue);
1942 RETURN_IF_EXCEPTION(throwScope, { });
1943 }
1944 return result;
1945}
1946
1947JSC::JSObject* convertDictionaryToJS(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject, const Internals::CookieData& dictionary)
1948{
1949 auto& vm = JSC::getVM(&lexicalGlobalObject);
1950 auto throwScope = DECLARE_THROW_SCOPE(vm);
1951
1952 auto result = constructEmptyObject(&lexicalGlobalObject, globalObject.objectPrototype());
1953
1954 if (!IDLDOMString::isNullValue(dictionary.domain)) {
1955 auto domainValue = toJS<IDLDOMString>(lexicalGlobalObject, throwScope, IDLDOMString::extractValueFromNullable(dictionary.domain));
1956 RETURN_IF_EXCEPTION(throwScope, { });
1957 result->putDirect(vm, JSC::Identifier::fromString(vm, "domain"), domainValue);
1958 }
1959 if (!IDLDouble::isNullValue(dictionary.expires)) {
1960 auto expiresValue = toJS<IDLDouble>(lexicalGlobalObject, throwScope, IDLDouble::extractValueFromNullable(dictionary.expires));
1961 RETURN_IF_EXCEPTION(throwScope, { });
1962 result->putDirect(vm, JSC::Identifier::fromString(vm, "expires"), expiresValue);
1963 }
1964 if (!IDLBoolean::isNullValue(dictionary.isHttpOnly)) {
1965 auto isHttpOnlyValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isHttpOnly));
1966 RETURN_IF_EXCEPTION(throwScope, { });
1967 result->putDirect(vm, JSC::Identifier::fromString(vm, "isHttpOnly"), isHttpOnlyValue);
1968 }
1969 if (!IDLBoolean::isNullValue(dictionary.isSameSiteLax)) {
1970 auto isSameSiteLaxValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isSameSiteLax));
1971 RETURN_IF_EXCEPTION(throwScope, { });
1972 result->putDirect(vm, JSC::Identifier::fromString(vm, "isSameSiteLax"), isSameSiteLaxValue);
1973 }
1974 if (!IDLBoolean::isNullValue(dictionary.isSameSiteStrict)) {
1975 auto isSameSiteStrictValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isSameSiteStrict));
1976 RETURN_IF_EXCEPTION(throwScope, { });
1977 result->putDirect(vm, JSC::Identifier::fromString(vm, "isSameSiteStrict"), isSameSiteStrictValue);
1978 }
1979 if (!IDLBoolean::isNullValue(dictionary.isSecure)) {
1980 auto isSecureValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isSecure));
1981 RETURN_IF_EXCEPTION(throwScope, { });
1982 result->putDirect(vm, JSC::Identifier::fromString(vm, "isSecure"), isSecureValue);
1983 }
1984 if (!IDLBoolean::isNullValue(dictionary.isSession)) {
1985 auto isSessionValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, IDLBoolean::extractValueFromNullable(dictionary.isSession));
1986 RETURN_IF_EXCEPTION(throwScope, { });
1987 result->putDirect(vm, JSC::Identifier::fromString(vm, "isSession"), isSessionValue);
1988 }
1989 if (!IDLDOMString::isNullValue(dictionary.name)) {
1990 auto nameValue = toJS<IDLDOMString>(lexicalGlobalObject, throwScope, IDLDOMString::extractValueFromNullable(dictionary.name));
1991 RETURN_IF_EXCEPTION(throwScope, { });
1992 result->putDirect(vm, JSC::Identifier::fromString(vm, "name"), nameValue);
1993 }
1994 if (!IDLDOMString::isNullValue(dictionary.value)) {
1995 auto valueValue = toJS<IDLDOMString>(lexicalGlobalObject, throwScope, IDLDOMString::extractValueFromNullable(dictionary.value));
1996 RETURN_IF_EXCEPTION(throwScope, { });
1997 result->putDirect(vm, JSC::Identifier::fromString(vm, "value"), valueValue);
1998 }
1999 return result;
2000}
2001
2002template<> Internals::TextIndicatorInfo convertDictionary<Internals::TextIndicatorInfo>(JSGlobalObject& lexicalGlobalObject, JSValue value)
2003{
2004 VM& vm = JSC::getVM(&lexicalGlobalObject);
2005 auto throwScope = DECLARE_THROW_SCOPE(vm);
2006 bool isNullOrUndefined = value.isUndefinedOrNull();
2007 auto* object = isNullOrUndefined ? nullptr : value.getObject();
2008 if (UNLIKELY(!isNullOrUndefined && !object)) {
2009 throwTypeError(&lexicalGlobalObject, throwScope);
2010 return { };
2011 }
2012 Internals::TextIndicatorInfo result;
2013 JSValue textBoundingRectInRootViewCoordinatesValue;
2014 if (isNullOrUndefined)
2015 textBoundingRectInRootViewCoordinatesValue = jsUndefined();
2016 else {
2017 textBoundingRectInRootViewCoordinatesValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "textBoundingRectInRootViewCoordinates"));
2018 RETURN_IF_EXCEPTION(throwScope, { });
2019 }
2020 if (!textBoundingRectInRootViewCoordinatesValue.isUndefined()) {
2021 result.textBoundingRectInRootViewCoordinates = convert<IDLInterface<DOMRectReadOnly>>(lexicalGlobalObject, textBoundingRectInRootViewCoordinatesValue);
2022 RETURN_IF_EXCEPTION(throwScope, { });
2023 }
2024 JSValue textRectsInBoundingRectCoordinatesValue;
2025 if (isNullOrUndefined)
2026 textRectsInBoundingRectCoordinatesValue = jsUndefined();
2027 else {
2028 textRectsInBoundingRectCoordinatesValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "textRectsInBoundingRectCoordinates"));
2029 RETURN_IF_EXCEPTION(throwScope, { });
2030 }
2031 if (!textRectsInBoundingRectCoordinatesValue.isUndefined()) {
2032 result.textRectsInBoundingRectCoordinates = convert<IDLInterface<DOMRectList>>(lexicalGlobalObject, textRectsInBoundingRectCoordinatesValue);
2033 RETURN_IF_EXCEPTION(throwScope, { });
2034 }
2035 return result;
2036}
2037
2038JSC::JSObject* convertDictionaryToJS(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject, const Internals::TextIndicatorInfo& dictionary)
2039{
2040 auto& vm = JSC::getVM(&lexicalGlobalObject);
2041 auto throwScope = DECLARE_THROW_SCOPE(vm);
2042
2043 auto result = constructEmptyObject(&lexicalGlobalObject, globalObject.objectPrototype());
2044
2045 if (!IDLInterface<DOMRectReadOnly>::isNullValue(dictionary.textBoundingRectInRootViewCoordinates)) {
2046 auto textBoundingRectInRootViewCoordinatesValue = toJS<IDLInterface<DOMRectReadOnly>>(lexicalGlobalObject, globalObject, throwScope, IDLInterface<DOMRectReadOnly>::extractValueFromNullable(dictionary.textBoundingRectInRootViewCoordinates));
2047 RETURN_IF_EXCEPTION(throwScope, { });
2048 result->putDirect(vm, JSC::Identifier::fromString(vm, "textBoundingRectInRootViewCoordinates"), textBoundingRectInRootViewCoordinatesValue);
2049 }
2050 if (!IDLInterface<DOMRectList>::isNullValue(dictionary.textRectsInBoundingRectCoordinates)) {
2051 auto textRectsInBoundingRectCoordinatesValue = toJS<IDLInterface<DOMRectList>>(lexicalGlobalObject, globalObject, throwScope, IDLInterface<DOMRectList>::extractValueFromNullable(dictionary.textRectsInBoundingRectCoordinates));
2052 RETURN_IF_EXCEPTION(throwScope, { });
2053 result->putDirect(vm, JSC::Identifier::fromString(vm, "textRectsInBoundingRectCoordinates"), textRectsInBoundingRectCoordinatesValue);
2054 }
2055 return result;
2056}
2057
2058#if ENABLE(ATTACHMENT_ELEMENT)
2059
2060template<> Internals::AttachmentThumbnailInfo convertDictionary<Internals::AttachmentThumbnailInfo>(JSGlobalObject& lexicalGlobalObject, JSValue value)
2061{
2062 VM& vm = JSC::getVM(&lexicalGlobalObject);
2063 auto throwScope = DECLARE_THROW_SCOPE(vm);
2064 bool isNullOrUndefined = value.isUndefinedOrNull();
2065 auto* object = isNullOrUndefined ? nullptr : value.getObject();
2066 if (UNLIKELY(!isNullOrUndefined && !object)) {
2067 throwTypeError(&lexicalGlobalObject, throwScope);
2068 return { };
2069 }
2070 Internals::AttachmentThumbnailInfo result;
2071 JSValue heightValue;
2072 if (isNullOrUndefined)
2073 heightValue = jsUndefined();
2074 else {
2075 heightValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "height"));
2076 RETURN_IF_EXCEPTION(throwScope, { });
2077 }
2078 if (!heightValue.isUndefined()) {
2079 result.height = convert<IDLUnsignedLong>(lexicalGlobalObject, heightValue);
2080 RETURN_IF_EXCEPTION(throwScope, { });
2081 }
2082 JSValue widthValue;
2083 if (isNullOrUndefined)
2084 widthValue = jsUndefined();
2085 else {
2086 widthValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "width"));
2087 RETURN_IF_EXCEPTION(throwScope, { });
2088 }
2089 if (!widthValue.isUndefined()) {
2090 result.width = convert<IDLUnsignedLong>(lexicalGlobalObject, widthValue);
2091 RETURN_IF_EXCEPTION(throwScope, { });
2092 }
2093 return result;
2094}
2095
2096JSC::JSObject* convertDictionaryToJS(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject, const Internals::AttachmentThumbnailInfo& dictionary)
2097{
2098 auto& vm = JSC::getVM(&lexicalGlobalObject);
2099 auto throwScope = DECLARE_THROW_SCOPE(vm);
2100
2101 auto result = constructEmptyObject(&lexicalGlobalObject, globalObject.objectPrototype());
2102
2103 if (!IDLUnsignedLong::isNullValue(dictionary.height)) {
2104 auto heightValue = toJS<IDLUnsignedLong>(lexicalGlobalObject, throwScope, IDLUnsignedLong::extractValueFromNullable(dictionary.height));
2105 RETURN_IF_EXCEPTION(throwScope, { });
2106 result->putDirect(vm, JSC::Identifier::fromString(vm, "height"), heightValue);
2107 }
2108 if (!IDLUnsignedLong::isNullValue(dictionary.width)) {
2109 auto widthValue = toJS<IDLUnsignedLong>(lexicalGlobalObject, throwScope, IDLUnsignedLong::extractValueFromNullable(dictionary.width));
2110 RETURN_IF_EXCEPTION(throwScope, { });
2111 result->putDirect(vm, JSC::Identifier::fromString(vm, "width"), widthValue);
2112 }
2113 return result;
2114}
2115
2116#endif
2117
2118template<> Internals::TextIndicatorOptions convertDictionary<Internals::TextIndicatorOptions>(JSGlobalObject& lexicalGlobalObject, JSValue value)
2119{
2120 VM& vm = JSC::getVM(&lexicalGlobalObject);
2121 auto throwScope = DECLARE_THROW_SCOPE(vm);
2122 bool isNullOrUndefined = value.isUndefinedOrNull();
2123 auto* object = isNullOrUndefined ? nullptr : value.getObject();
2124 if (UNLIKELY(!isNullOrUndefined && !object)) {
2125 throwTypeError(&lexicalGlobalObject, throwScope);
2126 return { };
2127 }
2128 Internals::TextIndicatorOptions result;
2129 JSValue computeEstimatedBackgroundColorValue;
2130 if (isNullOrUndefined)
2131 computeEstimatedBackgroundColorValue = jsUndefined();
2132 else {
2133 computeEstimatedBackgroundColorValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "computeEstimatedBackgroundColor"));
2134 RETURN_IF_EXCEPTION(throwScope, { });
2135 }
2136 if (!computeEstimatedBackgroundColorValue.isUndefined()) {
2137 result.computeEstimatedBackgroundColor = convert<IDLBoolean>(lexicalGlobalObject, computeEstimatedBackgroundColorValue);
2138 RETURN_IF_EXCEPTION(throwScope, { });
2139 } else
2140 result.computeEstimatedBackgroundColor = false;
2141 JSValue respectTextColorValue;
2142 if (isNullOrUndefined)
2143 respectTextColorValue = jsUndefined();
2144 else {
2145 respectTextColorValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "respectTextColor"));
2146 RETURN_IF_EXCEPTION(throwScope, { });
2147 }
2148 if (!respectTextColorValue.isUndefined()) {
2149 result.respectTextColor = convert<IDLBoolean>(lexicalGlobalObject, respectTextColorValue);
2150 RETURN_IF_EXCEPTION(throwScope, { });
2151 } else
2152 result.respectTextColor = false;
2153 JSValue useBoundingRectAndPaintAllContentForComplexRangesValue;
2154 if (isNullOrUndefined)
2155 useBoundingRectAndPaintAllContentForComplexRangesValue = jsUndefined();
2156 else {
2157 useBoundingRectAndPaintAllContentForComplexRangesValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "useBoundingRectAndPaintAllContentForComplexRanges"));
2158 RETURN_IF_EXCEPTION(throwScope, { });
2159 }
2160 if (!useBoundingRectAndPaintAllContentForComplexRangesValue.isUndefined()) {
2161 result.useBoundingRectAndPaintAllContentForComplexRanges = convert<IDLBoolean>(lexicalGlobalObject, useBoundingRectAndPaintAllContentForComplexRangesValue);
2162 RETURN_IF_EXCEPTION(throwScope, { });
2163 } else
2164 result.useBoundingRectAndPaintAllContentForComplexRanges = false;
2165 return result;
2166}
2167
2168JSC::JSObject* convertDictionaryToJS(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject, const Internals::TextIndicatorOptions& dictionary)
2169{
2170 auto& vm = JSC::getVM(&lexicalGlobalObject);
2171 auto throwScope = DECLARE_THROW_SCOPE(vm);
2172
2173 auto result = constructEmptyObject(&lexicalGlobalObject, globalObject.objectPrototype());
2174
2175 auto computeEstimatedBackgroundColorValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, dictionary.computeEstimatedBackgroundColor);
2176 RETURN_IF_EXCEPTION(throwScope, { });
2177 result->putDirect(vm, JSC::Identifier::fromString(vm, "computeEstimatedBackgroundColor"), computeEstimatedBackgroundColorValue);
2178 auto respectTextColorValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, dictionary.respectTextColor);
2179 RETURN_IF_EXCEPTION(throwScope, { });
2180 result->putDirect(vm, JSC::Identifier::fromString(vm, "respectTextColor"), respectTextColorValue);
2181 auto useBoundingRectAndPaintAllContentForComplexRangesValue = toJS<IDLBoolean>(lexicalGlobalObject, throwScope, dictionary.useBoundingRectAndPaintAllContentForComplexRanges);
2182 RETURN_IF_EXCEPTION(throwScope, { });
2183 result->putDirect(vm, JSC::Identifier::fromString(vm, "useBoundingRectAndPaintAllContentForComplexRanges"), useBoundingRectAndPaintAllContentForComplexRangesValue);
2184 return result;
2185}
2186
2187template<> Internals::ImageOverlayText convertDictionary<Internals::ImageOverlayText>(JSGlobalObject& lexicalGlobalObject, JSValue value)
2188{
2189 VM& vm = JSC::getVM(&lexicalGlobalObject);
2190 auto throwScope = DECLARE_THROW_SCOPE(vm);
2191 bool isNullOrUndefined = value.isUndefinedOrNull();
2192 auto* object = isNullOrUndefined ? nullptr : value.getObject();
2193 if (UNLIKELY(!isNullOrUndefined && !object)) {
2194 throwTypeError(&lexicalGlobalObject, throwScope);
2195 return { };
2196 }
2197 Internals::ImageOverlayText result;
2198 JSValue bottomLeftValue;
2199 if (isNullOrUndefined)
2200 bottomLeftValue = jsUndefined();
2201 else {
2202 bottomLeftValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "bottomLeft"));
2203 RETURN_IF_EXCEPTION(throwScope, { });
2204 }
2205 if (!bottomLeftValue.isUndefined()) {
2206 result.bottomLeft = convert<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, bottomLeftValue);
2207 RETURN_IF_EXCEPTION(throwScope, { });
2208 } else {
2209 throwRequiredMemberTypeError(lexicalGlobalObject, throwScope, "bottomLeft", "ImageOverlayText", "DOMPointReadOnly");
2210 return { };
2211 }
2212 JSValue bottomRightValue;
2213 if (isNullOrUndefined)
2214 bottomRightValue = jsUndefined();
2215 else {
2216 bottomRightValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "bottomRight"));
2217 RETURN_IF_EXCEPTION(throwScope, { });
2218 }
2219 if (!bottomRightValue.isUndefined()) {
2220 result.bottomRight = convert<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, bottomRightValue);
2221 RETURN_IF_EXCEPTION(throwScope, { });
2222 } else {
2223 throwRequiredMemberTypeError(lexicalGlobalObject, throwScope, "bottomRight", "ImageOverlayText", "DOMPointReadOnly");
2224 return { };
2225 }
2226 JSValue textValue;
2227 if (isNullOrUndefined)
2228 textValue = jsUndefined();
2229 else {
2230 textValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "text"));
2231 RETURN_IF_EXCEPTION(throwScope, { });
2232 }
2233 if (!textValue.isUndefined()) {
2234 result.text = convert<IDLDOMString>(lexicalGlobalObject, textValue);
2235 RETURN_IF_EXCEPTION(throwScope, { });
2236 } else {
2237 throwRequiredMemberTypeError(lexicalGlobalObject, throwScope, "text", "ImageOverlayText", "DOMString");
2238 return { };
2239 }
2240 JSValue topLeftValue;
2241 if (isNullOrUndefined)
2242 topLeftValue = jsUndefined();
2243 else {
2244 topLeftValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "topLeft"));
2245 RETURN_IF_EXCEPTION(throwScope, { });
2246 }
2247 if (!topLeftValue.isUndefined()) {
2248 result.topLeft = convert<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, topLeftValue);
2249 RETURN_IF_EXCEPTION(throwScope, { });
2250 } else {
2251 throwRequiredMemberTypeError(lexicalGlobalObject, throwScope, "topLeft", "ImageOverlayText", "DOMPointReadOnly");
2252 return { };
2253 }
2254 JSValue topRightValue;
2255 if (isNullOrUndefined)
2256 topRightValue = jsUndefined();
2257 else {
2258 topRightValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "topRight"));
2259 RETURN_IF_EXCEPTION(throwScope, { });
2260 }
2261 if (!topRightValue.isUndefined()) {
2262 result.topRight = convert<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, topRightValue);
2263 RETURN_IF_EXCEPTION(throwScope, { });
2264 } else {
2265 throwRequiredMemberTypeError(lexicalGlobalObject, throwScope, "topRight", "ImageOverlayText", "DOMPointReadOnly");
2266 return { };
2267 }
2268 return result;
2269}
2270
2271JSC::JSObject* convertDictionaryToJS(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject, const Internals::ImageOverlayText& dictionary)
2272{
2273 auto& vm = JSC::getVM(&lexicalGlobalObject);
2274 auto throwScope = DECLARE_THROW_SCOPE(vm);
2275
2276 auto result = constructEmptyObject(&lexicalGlobalObject, globalObject.objectPrototype());
2277
2278 auto bottomLeftValue = toJS<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, globalObject, throwScope, dictionary.bottomLeft);
2279 RETURN_IF_EXCEPTION(throwScope, { });
2280 result->putDirect(vm, JSC::Identifier::fromString(vm, "bottomLeft"), bottomLeftValue);
2281 auto bottomRightValue = toJS<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, globalObject, throwScope, dictionary.bottomRight);
2282 RETURN_IF_EXCEPTION(throwScope, { });
2283 result->putDirect(vm, JSC::Identifier::fromString(vm, "bottomRight"), bottomRightValue);
2284 auto textValue = toJS<IDLDOMString>(lexicalGlobalObject, throwScope, dictionary.text);
2285 RETURN_IF_EXCEPTION(throwScope, { });
2286 result->putDirect(vm, JSC::Identifier::fromString(vm, "text"), textValue);
2287 auto topLeftValue = toJS<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, globalObject, throwScope, dictionary.topLeft);
2288 RETURN_IF_EXCEPTION(throwScope, { });
2289 result->putDirect(vm, JSC::Identifier::fromString(vm, "topLeft"), topLeftValue);
2290 auto topRightValue = toJS<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, globalObject, throwScope, dictionary.topRight);
2291 RETURN_IF_EXCEPTION(throwScope, { });
2292 result->putDirect(vm, JSC::Identifier::fromString(vm, "topRight"), topRightValue);
2293 return result;
2294}
2295
2296template<> Internals::ImageOverlayLine convertDictionary<Internals::ImageOverlayLine>(JSGlobalObject& lexicalGlobalObject, JSValue value)
2297{
2298 VM& vm = JSC::getVM(&lexicalGlobalObject);
2299 auto throwScope = DECLARE_THROW_SCOPE(vm);
2300 bool isNullOrUndefined = value.isUndefinedOrNull();
2301 auto* object = isNullOrUndefined ? nullptr : value.getObject();
2302 if (UNLIKELY(!isNullOrUndefined && !object)) {
2303 throwTypeError(&lexicalGlobalObject, throwScope);
2304 return { };
2305 }
2306 Internals::ImageOverlayLine result;
2307 JSValue bottomLeftValue;
2308 if (isNullOrUndefined)
2309 bottomLeftValue = jsUndefined();
2310 else {
2311 bottomLeftValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "bottomLeft"));
2312 RETURN_IF_EXCEPTION(throwScope, { });
2313 }
2314 if (!bottomLeftValue.isUndefined()) {
2315 result.bottomLeft = convert<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, bottomLeftValue);
2316 RETURN_IF_EXCEPTION(throwScope, { });
2317 } else {
2318 throwRequiredMemberTypeError(lexicalGlobalObject, throwScope, "bottomLeft", "ImageOverlayLine", "DOMPointReadOnly");
2319 return { };
2320 }
2321 JSValue bottomRightValue;
2322 if (isNullOrUndefined)
2323 bottomRightValue = jsUndefined();
2324 else {
2325 bottomRightValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "bottomRight"));
2326 RETURN_IF_EXCEPTION(throwScope, { });
2327 }
2328 if (!bottomRightValue.isUndefined()) {
2329 result.bottomRight = convert<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, bottomRightValue);
2330 RETURN_IF_EXCEPTION(throwScope, { });
2331 } else {
2332 throwRequiredMemberTypeError(lexicalGlobalObject, throwScope, "bottomRight", "ImageOverlayLine", "DOMPointReadOnly");
2333 return { };
2334 }
2335 JSValue childrenValue;
2336 if (isNullOrUndefined)
2337 childrenValue = jsUndefined();
2338 else {
2339 childrenValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "children"));
2340 RETURN_IF_EXCEPTION(throwScope, { });
2341 }
2342 if (!childrenValue.isUndefined()) {
2343 result.children = convert<IDLSequence<IDLDictionary<Internals::ImageOverlayText>>>(lexicalGlobalObject, childrenValue);
2344 RETURN_IF_EXCEPTION(throwScope, { });
2345 }
2346 JSValue topLeftValue;
2347 if (isNullOrUndefined)
2348 topLeftValue = jsUndefined();
2349 else {
2350 topLeftValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "topLeft"));
2351 RETURN_IF_EXCEPTION(throwScope, { });
2352 }
2353 if (!topLeftValue.isUndefined()) {
2354 result.topLeft = convert<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, topLeftValue);
2355 RETURN_IF_EXCEPTION(throwScope, { });
2356 } else {
2357 throwRequiredMemberTypeError(lexicalGlobalObject, throwScope, "topLeft", "ImageOverlayLine", "DOMPointReadOnly");
2358 return { };
2359 }
2360 JSValue topRightValue;
2361 if (isNullOrUndefined)
2362 topRightValue = jsUndefined();
2363 else {
2364 topRightValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "topRight"));
2365 RETURN_IF_EXCEPTION(throwScope, { });
2366 }
2367 if (!topRightValue.isUndefined()) {
2368 result.topRight = convert<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, topRightValue);
2369 RETURN_IF_EXCEPTION(throwScope, { });
2370 } else {
2371 throwRequiredMemberTypeError(lexicalGlobalObject, throwScope, "topRight", "ImageOverlayLine", "DOMPointReadOnly");
2372 return { };
2373 }
2374 return result;
2375}
2376
2377JSC::JSObject* convertDictionaryToJS(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject, const Internals::ImageOverlayLine& dictionary)
2378{
2379 auto& vm = JSC::getVM(&lexicalGlobalObject);
2380 auto throwScope = DECLARE_THROW_SCOPE(vm);
2381
2382 auto result = constructEmptyObject(&lexicalGlobalObject, globalObject.objectPrototype());
2383
2384 auto bottomLeftValue = toJS<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, globalObject, throwScope, dictionary.bottomLeft);
2385 RETURN_IF_EXCEPTION(throwScope, { });
2386 result->putDirect(vm, JSC::Identifier::fromString(vm, "bottomLeft"), bottomLeftValue);
2387 auto bottomRightValue = toJS<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, globalObject, throwScope, dictionary.bottomRight);
2388 RETURN_IF_EXCEPTION(throwScope, { });
2389 result->putDirect(vm, JSC::Identifier::fromString(vm, "bottomRight"), bottomRightValue);
2390 if (!IDLSequence<IDLDictionary<Internals::ImageOverlayText>>::isNullValue(dictionary.children)) {
2391 auto childrenValue = toJS<IDLSequence<IDLDictionary<Internals::ImageOverlayText>>>(lexicalGlobalObject, globalObject, throwScope, IDLSequence<IDLDictionary<Internals::ImageOverlayText>>::extractValueFromNullable(dictionary.children));
2392 RETURN_IF_EXCEPTION(throwScope, { });
2393 result->putDirect(vm, JSC::Identifier::fromString(vm, "children"), childrenValue);
2394 }
2395 auto topLeftValue = toJS<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, globalObject, throwScope, dictionary.topLeft);
2396 RETURN_IF_EXCEPTION(throwScope, { });
2397 result->putDirect(vm, JSC::Identifier::fromString(vm, "topLeft"), topLeftValue);
2398 auto topRightValue = toJS<IDLInterface<DOMPointReadOnly>>(lexicalGlobalObject, globalObject, throwScope, dictionary.topRight);
2399 RETURN_IF_EXCEPTION(throwScope, { });
2400 result->putDirect(vm, JSC::Identifier::fromString(vm, "topRight"), topRightValue);
2401 return result;
2402}
2403
2404// Functions
2405
2406static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_address);
2407static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_nodeNeedsStyleRecalc);
2408static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_styleChangeType);
2409static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_description);
2410static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_log);
2411static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasPausedImageAnimations);
2412static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isPaintingFrequently);
2413static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_incrementFrequentPaintCounter);
2414static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_elementRenderTreeAsText);
2415static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isPreloaded);
2416static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isLoadingFromMemoryCache);
2417static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_fetchResponseSource);
2418static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_xhrResponseSource);
2419static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isSharingStyleSheetContents);
2420static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isStyleSheetLoadingSubresources);
2421static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_clearMemoryCache);
2422static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pruneMemoryCacheToSize);
2423static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_destroyDecodedDataForAllImages);
2424static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_memoryCacheSize);
2425static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setOverrideCachePolicy);
2426static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setOverrideResourceLoadPriority);
2427static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setStrictRawResourceValidationPolicyDisabled);
2428static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_clearBackForwardCache);
2429static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_backForwardCacheSize);
2430static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_preventDocumentFromEnteringBackForwardCache);
2431static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_computedStyleIncludingVisitedInfo);
2432static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_ensureUserAgentShadowRoot);
2433static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_shadowRoot);
2434static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_deferredStyleRulesCount);
2435static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_deferredGroupRulesCount);
2436static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_deferredKeyframesRulesCount);
2437static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_shadowRootType);
2438static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_shadowPseudoId);
2439static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setShadowPseudoId);
2440static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_treeScopeRootNode);
2441static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_parentTreeScope);
2442static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_lastSpatialNavigationCandidateCount);
2443static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_animationWithIdExists);
2444static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfActiveAnimations);
2445static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_suspendAnimations);
2446static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_resumeAnimations);
2447static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_animationsAreSuspended);
2448static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_acceleratedAnimationsForElement);
2449static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfAnimationTimelineInvalidations);
2450static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_timeToNextAnimationTick);
2451static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pseudoElement);
2452static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_visiblePlaceholder);
2453static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_selectColorInColorChooser);
2454static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_formControlStateOfPreviousHistoryItem);
2455static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setFormControlStateOfPreviousHistoryItem);
2456static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_absoluteLineRectFromPoint);
2457static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_absoluteCaretBounds);
2458static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isCaretBlinkingSuspended);
2459static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_boundingBox);
2460static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_inspectorGridOverlayCount);
2461static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_inspectorHighlightRects);
2462static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_markerCountForNode);
2463static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_markerRangeForNode);
2464static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_markerDescriptionForNode);
2465static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_dumpMarkerRects);
2466static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMarkedTextMatchesAreHighlighted);
2467static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_invalidateFontCache);
2468static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setFontSmoothingEnabled);
2469static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setScrollViewPosition);
2470static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_unconstrainedScrollTo);
2471static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_scrollBySimulatingWheelEvent);
2472static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_layoutViewportRect);
2473static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_visualViewportRect);
2474static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setViewIsTransparent);
2475static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_viewBaseBackgroundColor);
2476static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setViewBaseBackgroundColor);
2477static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPagination);
2478static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPaginationLineGridEnabled);
2479static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_configurationForViewport);
2480static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_wasLastChangeUserEdit);
2481static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_elementShouldAutoComplete);
2482static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAutofilled);
2483static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAutoFilledAndViewable);
2484static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setShowAutoFillButton);
2485static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_autoFillButtonType);
2486static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_lastAutoFillButtonType);
2487static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setCanShowPlaceholder);
2488static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_insertTextPlaceholder);
2489static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_removeTextPlaceholder);
2490static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeOfString);
2491static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_countMatchesForText);
2492static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_countFindMatches);
2493static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_autofillFieldName);
2494static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isSpellcheckDisabledExceptTextReplacement);
2495static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_invalidateControlTints);
2496static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_scrollElementToRect);
2497static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeFromLocationAndLength);
2498static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_locationFromRange);
2499static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_lengthFromRange);
2500static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeAsText);
2501static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeAsTextUsingBackwardsTextIterator);
2502static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_subrange);
2503static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeForDictionaryLookupAtLocation);
2504static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeOfStringNearLocation);
2505static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setDelegatesScrolling);
2506static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_lastSpellCheckRequestSequence);
2507static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_lastSpellCheckProcessedSequence);
2508static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_advanceToNextMisspelling);
2509static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_userPreferredLanguages);
2510static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUserPreferredLanguages);
2511static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_userPreferredAudioCharacteristics);
2512static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUserPreferredAudioCharacteristic);
2513static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_wheelEventHandlerCount);
2514static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_touchEventHandlerCount);
2515static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_touchEventRectsForEvent);
2516static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_passiveTouchEventListenerRects);
2517static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_nodesFromRect);
2518static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_parserMetaData);
2519static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_updateEditorUINowIfScheduled);
2520static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasSpellingMarker);
2521static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasGrammarMarker);
2522static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasAutocorrectedMarker);
2523static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasDictationAlternativesMarker);
2524static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setContinuousSpellCheckingEnabled);
2525static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAutomaticQuoteSubstitutionEnabled);
2526static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAutomaticLinkDetectionEnabled);
2527static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAutomaticDashSubstitutionEnabled);
2528static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAutomaticTextReplacementEnabled);
2529static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAutomaticSpellingCorrectionEnabled);
2530static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_handleAcceptedCandidate);
2531static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_changeSelectionListType);
2532static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_changeBackToReplacedString);
2533static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isOverwriteModeEnabled);
2534static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_toggleOverwriteModeEnabled);
2535static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfScrollableAreas);
2536static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isPageBoxVisible);
2537static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_imageFrameIndex);
2538static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_imageFrameCount);
2539static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_imageFrameDurationAtIndex);
2540static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setImageFrameDecodingDuration);
2541static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_resetImageAnimation);
2542static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isImageAnimating);
2543static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_imagePendingDecodePromisesCountForTesting);
2544static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setClearDecoderAfterAsyncFrameRequestForTesting);
2545static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_imageDecodeCount);
2546static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pdfDocumentCachingCount);
2547static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setLargeImageAsyncDecodingEnabledForTesting);
2548static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setForceUpdateImageDataEnabledForTesting);
2549static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setGridMaxTracksLimit);
2550static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_svgAnimationsInterval);
2551static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_testProcessIncomingSyncMessagesWhenWaitingForSyncReply);
2552static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_layerTreeAsText);
2553static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_layerIDForElement);
2554static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_platformLayerTreeAsText);
2555static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_scrollbarOverlayStyle);
2556static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_scrollbarUsingDarkAppearance);
2557static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_horizontalScrollbarState);
2558static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_verticalScrollbarState);
2559static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_scrollingStateTreeAsText);
2560static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_scrollingTreeAsText);
2561static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_synchronousScrollingReasons);
2562static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_nonFastScrollableRects);
2563static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_repaintRectsAsText);
2564static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setElementUsesDisplayListDrawing);
2565static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setElementTracksDisplayListReplay);
2566static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_displayListForElement);
2567static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_replayDisplayListForElement);
2568static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_garbageCollectDocumentResources);
2569static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_insertAuthorCSS);
2570static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_insertUserCSS);
2571static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_beginSimulatedMemoryPressure);
2572static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_endSimulatedMemoryPressure);
2573static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfIDBTransactions);
2574static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfLiveNodes);
2575static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfLiveDocuments);
2576static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_referencingNodeCount);
2577#if ENABLE(INTERSECTION_OBSERVER)
2578static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfIntersectionObservers);
2579#endif
2580#if ENABLE(RESIZE_OBSERVER)
2581static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfResizeObservers);
2582#endif
2583static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_openDummyInspectorFrontend);
2584static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_closeDummyInspectorFrontend);
2585static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setInspectorIsUnderTest);
2586#if ENABLE(WEB_AUDIO)
2587static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_baseAudioContextIdentifier);
2588#endif
2589#if ENABLE(WEB_AUDIO)
2590static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isBaseAudioContextAlive);
2591#endif
2592static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_counterValue);
2593static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageNumber);
2594static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_shortcutIconURLs);
2595static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfPages);
2596static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageProperty);
2597static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageSizeAndMarginsInPixels);
2598static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageScaleFactor);
2599static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageScaleFactor);
2600static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageZoomFactor);
2601static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setTextZoomFactor);
2602static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUseFixedLayout);
2603static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setFixedLayoutSize);
2604static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPrinting);
2605static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setViewExposedRect);
2606static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setHeaderHeight);
2607static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setFooterHeight);
2608static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setTopContentInset);
2609#if ENABLE(FULLSCREEN_API)
2610static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_webkitWillEnterFullScreenForElement);
2611#endif
2612#if ENABLE(FULLSCREEN_API)
2613static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_webkitDidEnterFullScreenForElement);
2614#endif
2615#if ENABLE(FULLSCREEN_API)
2616static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_webkitWillExitFullScreenForElement);
2617#endif
2618#if ENABLE(FULLSCREEN_API)
2619static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_webkitDidExitFullScreenForElement);
2620#endif
2621static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setFullscreenInsets);
2622static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setFullscreenAutoHideDuration);
2623static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setFullscreenControlsHidden);
2624#if ENABLE(VIDEO)
2625static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isChangingPresentationMode);
2626#endif
2627#if ENABLE(VIDEO_PRESENTATION_MODE)
2628static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMockVideoPresentationModeEnabled);
2629#endif
2630static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setApplicationCacheOriginQuota);
2631static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_registerURLSchemeAsBypassingContentSecurityPolicy);
2632static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_removeURLSchemeRegisteredAsBypassingContentSecurityPolicy);
2633static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_registerDefaultPortForProtocol);
2634static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_mallocStatistics);
2635static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_typeConversions);
2636static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_memoryInfo);
2637static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_getReferencedFilePaths);
2638static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_startTrackingRepaints);
2639static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_stopTrackingRepaints);
2640static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_startTrackingLayerFlushes);
2641static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_layerFlushCount);
2642static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isTimerThrottled);
2643static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_requestAnimationFrameThrottlingReasons);
2644static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_areTimersThrottled);
2645static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setLowPowerModeEnabled);
2646static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setOutsideViewportThrottlingEnabled);
2647static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_startTrackingStyleRecalcs);
2648static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_styleRecalcCount);
2649static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_startTrackingCompositingUpdates);
2650static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_compositingUpdateCount);
2651static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_startTrackingRenderingUpdates);
2652static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_renderingUpdateCount);
2653static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_updateLayoutAndStyleForAllFrames);
2654static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks);
2655static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_getCurrentCursorInfo);
2656static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_markerTextForListItem);
2657static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_toolTipFromElement);
2658static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_deserializeBuffer);
2659static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_serializeObject);
2660static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isFromCurrentWorld);
2661static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_evaluateInWorldIgnoringException);
2662static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUsesOverlayScrollbars);
2663static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUsesMockScrollAnimator);
2664static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_forceReload);
2665static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_reloadExpiredOnly);
2666static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_enableFixedWidthAutoSizeMode);
2667static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_enableSizeToContentAutoSizeMode);
2668#if ENABLE(VIDEO)
2669static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaResponseSources);
2670#endif
2671#if ENABLE(VIDEO)
2672static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaResponseContentRanges);
2673#endif
2674#if ENABLE(VIDEO)
2675static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_simulateAudioInterruption);
2676#endif
2677#if ENABLE(VIDEO)
2678static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaElementHasCharacteristic);
2679#endif
2680#if ENABLE(VIDEO)
2681static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_beginSimulatedHDCPError);
2682#endif
2683#if ENABLE(VIDEO)
2684static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_endSimulatedHDCPError);
2685#endif
2686#if ENABLE(VIDEO)
2687static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_elementShouldBufferData);
2688#endif
2689#if ENABLE(VIDEO)
2690static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_elementBufferingPolicy);
2691#endif
2692#if ENABLE(VIDEO)
2693static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_privatePlayerVolume);
2694#endif
2695#if ENABLE(VIDEO)
2696static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_privatePlayerMuted);
2697#endif
2698#if ENABLE(VIDEO)
2699static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isMediaElementHidden);
2700#endif
2701#if ENABLE(VIDEO)
2702static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setOverridePreferredDynamicRangeMode);
2703#endif
2704static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setIsPlayingToBluetoothOverride);
2705#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
2706static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_initializeMockCDM);
2707#endif
2708#if ENABLE(ENCRYPTED_MEDIA)
2709static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_registerMockCDM);
2710#endif
2711static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_enableMockMediaCapabilities);
2712#if ENABLE(SPEECH_SYNTHESIS)
2713static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_enableMockSpeechSynthesizer);
2714#endif
2715static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_getImageSourceURL);
2716#if ENABLE(VIDEO)
2717static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_captionsStyleSheetOverride);
2718#endif
2719#if ENABLE(VIDEO)
2720static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setCaptionsStyleSheetOverride);
2721#endif
2722#if ENABLE(VIDEO)
2723static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPrimaryAudioTrackLanguageOverride);
2724#endif
2725#if ENABLE(VIDEO)
2726static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setCaptionDisplayMode);
2727#endif
2728#if ENABLE(VIDEO)
2729static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_createGenericCue);
2730#endif
2731#if ENABLE(VIDEO)
2732static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_textTrackBCP47Language);
2733#endif
2734#if ENABLE(VIDEO)
2735static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_createTimeRanges);
2736#endif
2737#if ENABLE(VIDEO)
2738static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_closestTimeToTimeRanges);
2739#endif
2740static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isSelectPopupVisible);
2741static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isPluginUnavailabilityIndicatorObscured);
2742static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_unavailablePluginReplacementText);
2743static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isPluginSnapshotted);
2744static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pluginIsBelowSizeThreshold);
2745static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_selectionBounds);
2746static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setSelectionWithoutValidation);
2747#if ENABLE(MEDIA_SOURCE)
2748static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_initializeMockMediaSource);
2749#endif
2750#if ENABLE(MEDIA_SOURCE)
2751static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_bufferedSamplesForTrackId);
2752#endif
2753#if ENABLE(MEDIA_SOURCE)
2754static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_enqueuedSamplesForTrackID);
2755#endif
2756#if ENABLE(MEDIA_SOURCE)
2757static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setShouldGenerateTimestamps);
2758#endif
2759#if ENABLE(MEDIA_SOURCE)
2760static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_minimumUpcomingPresentationTimeForTrackID);
2761#endif
2762#if ENABLE(MEDIA_SOURCE)
2763static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMaximumQueueDepthForTrackID);
2764#endif
2765#if ENABLE(VIDEO)
2766static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_beginMediaSessionInterruption);
2767#endif
2768#if ENABLE(VIDEO)
2769static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_endMediaSessionInterruption);
2770#endif
2771#if ENABLE(VIDEO)
2772static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_applicationWillBecomeInactive);
2773#endif
2774#if ENABLE(VIDEO)
2775static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_applicationDidBecomeActive);
2776#endif
2777#if ENABLE(VIDEO)
2778static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_applicationWillEnterForeground);
2779#endif
2780#if ENABLE(VIDEO)
2781static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_applicationDidEnterBackground);
2782#endif
2783#if ENABLE(VIDEO)
2784static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMediaSessionRestrictions);
2785#endif
2786#if ENABLE(VIDEO)
2787static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaSessionRestrictions);
2788#endif
2789#if ENABLE(VIDEO)
2790static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMediaElementRestrictions);
2791#endif
2792#if ENABLE(WEB_AUDIO)
2793static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAudioContextRestrictions);
2794#endif
2795#if ENABLE(VIDEO)
2796static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_postRemoteControlCommand);
2797#endif
2798#if ENABLE(VIDEO)
2799static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_activeAudioRouteDidChange);
2800#endif
2801#if ENABLE(WIRELESS_PLAYBACK_TARGET)
2802static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMockMediaPlaybackTargetPickerEnabled);
2803#endif
2804#if ENABLE(WIRELESS_PLAYBACK_TARGET)
2805static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMockMediaPlaybackTargetPickerState);
2806#endif
2807#if ENABLE(WIRELESS_PLAYBACK_TARGET)
2808static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_mockMediaPlaybackTargetPickerDismissPopup);
2809#endif
2810#if ENABLE(MEDIA_STREAM)
2811static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setCustomPrivateRecorderCreator);
2812#endif
2813#if ENABLE(WEB_AUDIO)
2814static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_useMockAudioDestinationCocoa);
2815#endif
2816#if ENABLE(WEB_RTC)
2817static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_emulateRTCPeerConnectionPlatformEvent);
2818#endif
2819#if ENABLE(WEB_RTC)
2820static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_useMockRTCPeerConnectionFactory);
2821#endif
2822#if ENABLE(WEB_RTC)
2823static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setICECandidateFiltering);
2824#endif
2825#if ENABLE(WEB_RTC)
2826static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setEnumeratingAllNetworkInterfacesEnabled);
2827#endif
2828#if ENABLE(WEB_RTC)
2829static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_stopPeerConnection);
2830#endif
2831#if ENABLE(WEB_RTC)
2832static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_clearPeerConnectionFactory);
2833#endif
2834#if ENABLE(WEB_RTC)
2835static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setEnableWebRTCEncryption);
2836#endif
2837#if ENABLE(WEB_RTC)
2838static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUseDTLS10);
2839#endif
2840#if ENABLE(VIDEO)
2841static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_simulateSystemSleep);
2842#endif
2843#if ENABLE(VIDEO)
2844static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_simulateSystemWake);
2845#endif
2846#if ENABLE(VIDEO)
2847static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_elementIsBlockingDisplaySleep);
2848#endif
2849static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_installMockPageOverlay);
2850static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageOverlayLayerTreeAsText);
2851static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageMuted);
2852static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageMediaState);
2853static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageDefersLoading);
2854static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageDefersLoading);
2855static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_createFile);
2856static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_queueMicroTask);
2857static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_testPreloaderSettingViewport);
2858static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_scrollSnapOffsets);
2859static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isScrollSnapInProgress);
2860static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPlatformMomentumScrollingPredictionEnabled);
2861static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pathStringWithShrinkWrappedRects);
2862#if ENABLE(VIDEO)
2863static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_getCurrentMediaControlsStatusForElement);
2864#endif
2865#if ENABLE(VIDEO)
2866static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMediaControlsMaximumRightContainerButtonCountOverride);
2867#endif
2868#if ENABLE(VIDEO)
2869static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMediaControlsHidePlaybackRates);
2870#endif
2871static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_userVisibleString);
2872static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageMediaVolume);
2873static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setShowAllPlugins);
2874static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_cloneArrayBuffer);
2875static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isReadableStreamDisturbed);
2876static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_resourceLoadStatisticsForURL);
2877static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setResourceLoadStatisticsEnabled);
2878static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setCanShowModalDialogOverride);
2879static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_composedTreeAsText);
2880static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isProcessingUserGesture);
2881static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_lastHandledUserGestureTimestamp);
2882static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_withUserGesture);
2883static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_withoutUserGesture);
2884static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_userIsInteracting);
2885static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_observeGC);
2886static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUserInterfaceLayoutDirection);
2887static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setBaseWritingDirection);
2888static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_userPrefersContrast);
2889static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_userPrefersReducedMotion);
2890static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_reportBacktrace);
2891#if ENABLE(POINTER_LOCK)
2892static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageHasPendingPointerLock);
2893#endif
2894#if ENABLE(POINTER_LOCK)
2895static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageHasPointerLock);
2896#endif
2897static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_accessKeyModifiers);
2898static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setQuickLookPassword);
2899static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAsRunningUserScripts);
2900#if ENABLE(APPLE_PAY)
2901static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setApplePayIsActive);
2902#endif
2903static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_disableTileSizeUpdateDelay);
2904static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setSpeculativeTilingDelayDisabledForTesting);
2905#if ENABLE(WEBGL)
2906static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_simulateEventForWebGLContext);
2907#endif
2908#if ENABLE(WEBGL)
2909static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasLowAndHighPowerGPUs);
2910#endif
2911static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageVisibility);
2912static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageIsFocusedAndActive);
2913static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageIsInWindow);
2914static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isPageActive);
2915#if ENABLE(WEB_RTC)
2916static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setH264HardwareEncoderAllowed);
2917#endif
2918#if ENABLE(WEB_RTC)
2919static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_applyRotationForOutgoingVideoSources);
2920#endif
2921#if ENABLE(WEB_RTC)
2922static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setWebRTCH265Support);
2923#endif
2924#if ENABLE(WEB_RTC)
2925static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setWebRTCVP9Support);
2926#endif
2927#if ENABLE(WEB_RTC)
2928static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setWebRTCVP9VTBSupport);
2929#endif
2930#if ENABLE(WEB_RTC)
2931static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setSFrameCounter);
2932#endif
2933#if ENABLE(WEB_RTC)
2934static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_sframeCounter);
2935#endif
2936#if ENABLE(WEB_RTC)
2937static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_sframeKeyId);
2938#endif
2939#if ENABLE(MEDIA_STREAM)
2940static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMockAudioTrackChannelNumber);
2941#endif
2942#if ENABLE(MEDIA_STREAM)
2943static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setShouldInterruptAudioOnPageVisibilityChange);
2944#endif
2945#if ENABLE(MEDIA_STREAM)
2946static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setCameraMediaStreamTrackOrientation);
2947#endif
2948#if ENABLE(MEDIA_STREAM)
2949static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_observeMediaStreamTrack);
2950#endif
2951#if ENABLE(MEDIA_STREAM)
2952static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_grabNextMediaStreamTrackFrame);
2953#endif
2954#if ENABLE(MEDIA_STREAM)
2955static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_delayMediaStreamTrackSamples);
2956#endif
2957#if ENABLE(MEDIA_STREAM)
2958static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMediaStreamTrackMuted);
2959#endif
2960#if ENABLE(MEDIA_STREAM)
2961static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_removeMediaStreamTrack);
2962#endif
2963#if ENABLE(MEDIA_STREAM)
2964static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_simulateMediaStreamTrackCaptureSourceFailure);
2965#endif
2966#if ENABLE(MEDIA_STREAM)
2967static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMediaStreamTrackIdentifier);
2968#endif
2969#if ENABLE(MEDIA_STREAM)
2970static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMediaStreamSourceInterrupted);
2971#endif
2972#if ENABLE(MEDIA_STREAM)
2973static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isMediaStreamSourceInterrupted);
2974#endif
2975#if ENABLE(MEDIA_STREAM)
2976static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isMediaStreamSourceEnded);
2977#endif
2978#if ENABLE(MEDIA_STREAM)
2979static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isMockRealtimeMediaSourceCenterEnabled);
2980#endif
2981#if ENABLE(MEDIA_STREAM)
2982static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_shouldAudioTrackPlay);
2983#endif
2984static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_documentIdentifier);
2985static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isDocumentAlive);
2986static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_elementIdentifier);
2987static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isElementAlive);
2988static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_frameIdentifier);
2989static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageIdentifier);
2990static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isAnyWorkletGlobalScopeAlive);
2991static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_serviceWorkerClientIdentifier);
2992static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_storeRegistrationsOnDisk);
2993static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_sendH2Ping);
2994static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_clearCacheStorageMemoryRepresentation);
2995static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_cacheStorageEngineRepresentation);
2996static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setResponseSizeWithPadding);
2997static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_responseSizeWithPadding);
2998static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_updateQuotaBasedOnSpaceUsage);
2999static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setConsoleMessageListener);
3000static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_audioSessionCategory);
3001static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_preferredAudioBufferSize);
3002static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_currentAudioBufferSize);
3003static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_audioSessionActive);
3004#if ENABLE(SERVICE_WORKER)
3005static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasServiceWorkerRegistration);
3006#endif
3007#if ENABLE(SERVICE_WORKER)
3008static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_terminateServiceWorker);
3009#endif
3010#if ENABLE(SERVICE_WORKER)
3011static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_whenServiceWorkerIsTerminated);
3012#endif
3013static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isSystemPreviewLink);
3014static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isSystemPreviewImage);
3015static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_installImageOverlay);
3016static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_usingAppleInternalSDK);
3017static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_usingGStreamer);
3018static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_postTask);
3019static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_queueTask);
3020static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_queueTaskToQueueMicrotask);
3021static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasSameEventLoopAs);
3022static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_windowLocationHost);
3023static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_markContextAsInsecure);
3024static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMaxCanvasPixelMemory);
3025#if ENABLE(VIDEO)
3026static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_bestMediaElementForRemoteControls);
3027#endif
3028#if ENABLE(VIDEO)
3029static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaSessionState);
3030#endif
3031#if ENABLE(VIDEO)
3032static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaUsageState);
3033#endif
3034#if ENABLE(VIDEO)
3035static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_elementShouldDisplayPosterImage);
3036#endif
3037static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_ongoingLoadsDescriptions);
3038static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setCaptureExtraNetworkLoadMetricsEnabled);
3039static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_reloadWithoutContentExtensions);
3040static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUseSystemAppearance);
3041static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_pluginCount);
3042static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_notifyResourceLoadObserver);
3043static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_primaryScreenDisplayID);
3044static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_capsLockIsOn);
3045static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_parseHEVCCodecParameters);
3046static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_parseDoViCodecParameters);
3047static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_parseVPCodecParameters);
3048static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_getCookies);
3049static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAlwaysAllowLocalWebarchive);
3050static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_processWillSuspend);
3051static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_processDidResume);
3052static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_testDictionaryLogging);
3053static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMaximumIntervalForUserGestureForwardingForFetch);
3054static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setTransientActivationDuration);
3055static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setIsPlayingToAutomotiveHeadUnit);
3056static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_textIndicatorForRange);
3057static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_addPrefetchLoadEventListener);
3058#if ENABLE(WEB_AUTHN)
3059static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMockWebAuthenticationConfiguration);
3060#endif
3061static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_createInternalsMapLike);
3062static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_createInternalsSetLike);
3063static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_highlightPseudoElementColor);
3064static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasSandboxMachLookupAccessToGlobalName);
3065static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasSandboxMachLookupAccessToXPCServiceName);
3066static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasSandboxIOKitOpenAccessToClass);
3067static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_systemColorForCSSValue);
3068static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_focusRingColor);
3069static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_systemHasBattery);
3070static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setSystemHasBatteryForTesting);
3071static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setSystemHasACForTesting);
3072static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setHardwareVP9DecoderDisabledForTesting);
3073static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setVP9ScreenSizeAndScaleForTesting);
3074static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_readPreferenceInteger);
3075static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_encodedPreferenceValue);
3076static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_getUTIFromTag);
3077static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_supportsPictureInPicture);
3078static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_isRemoteUIAppForAccessibility);
3079static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_createSleepDisabler);
3080static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_destroySleepDisabler);
3081#if ENABLE(APP_HIGHLIGHTS)
3082static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfAppHighlights);
3083#endif
3084#if ENABLE(ENCRYPTED_MEDIA)
3085static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaKeysInternalInstanceObjectRefCount);
3086#endif
3087#if ENABLE(ENCRYPTED_MEDIA)
3088static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaKeySessionInternalInstanceSessionObjectRefCount);
3089#endif
3090static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setContentSizeCategory);
3091#if ENABLE(ATTACHMENT_ELEMENT)
3092static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_attachmentThumbnailInfo);
3093#endif
3094#if ENABLE(MEDIA_SESSION)
3095static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_currentMediaSessionPosition);
3096#endif
3097#if ENABLE(MEDIA_SESSION)
3098static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_sendMediaSessionAction);
3099#endif
3100#if ENABLE(MEDIA_SESSION)
3101static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_loadArtworkImage);
3102#endif
3103#if ENABLE(MEDIA_SESSION_COORDINATOR)
3104static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_registerMockMediaSessionCoordinator);
3105#endif
3106#if ENABLE(MEDIA_SESSION_COORDINATOR)
3107static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMockMediaSessionCoordinatorCommandsShouldFail);
3108#endif
3109static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_treeOrder);
3110static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_treeOrderBoundaryPoints);
3111static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeContainsNode);
3112static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeContainsRange);
3113static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeContainsBoundaryPoint);
3114static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeIntersectsNode);
3115static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeIntersectsRange);
3116static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_systemBeep);
3117static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_dumpStyleResolvers);
3118static JSC_DECLARE_HOST_FUNCTION(jsInternalsPrototypeFunction_setDocumentAutoplayPolicy);
3119
3120// Attributes
3121
3122static JSC_DECLARE_CUSTOM_GETTER(jsInternals_inflightBeaconsCount);
3123static JSC_DECLARE_CUSTOM_GETTER(jsInternals_animationsInterval);
3124static JSC_DECLARE_CUSTOM_GETTER(jsInternals_sentenceRetroCorrectionEnabled);
3125static JSC_DECLARE_CUSTOM_GETTER(jsInternals_settings);
3126static JSC_DECLARE_CUSTOM_GETTER(jsInternals_workerThreadCount);
3127static JSC_DECLARE_CUSTOM_GETTER(jsInternals_areSVGAnimationsPaused);
3128static JSC_DECLARE_CUSTOM_GETTER(jsInternals_isUnderMemoryPressure);
3129#if ENABLE(FULLSCREEN_API)
3130static JSC_DECLARE_CUSTOM_GETTER(jsInternals_isAnimatingFullScreen);
3131#endif
3132static JSC_DECLARE_CUSTOM_GETTER(jsInternals_requestAnimationFrameInterval);
3133static JSC_DECLARE_CUSTOM_GETTER(jsInternals_scriptedAnimationsAreSuspended);
3134static JSC_DECLARE_CUSTOM_GETTER(jsInternals_eventThrottlingBehaviorOverride);
3135static JSC_DECLARE_CUSTOM_SETTER(setJSInternals_eventThrottlingBehaviorOverride);
3136static JSC_DECLARE_CUSTOM_GETTER(jsInternals_lastStyleUpdateSize);
3137static JSC_DECLARE_CUSTOM_GETTER(jsInternals_compositingPolicyOverride);
3138static JSC_DECLARE_CUSTOM_SETTER(setJSInternals_compositingPolicyOverride);
3139static JSC_DECLARE_CUSTOM_GETTER(jsInternals_layoutCount);
3140#if ENABLE(CONTENT_FILTERING)
3141static JSC_DECLARE_CUSTOM_GETTER(jsInternals_mockContentFilterSettings);
3142#endif
3143#if ENABLE(MEDIA_STREAM)
3144static JSC_DECLARE_CUSTOM_GETTER(jsInternals_trackAudioSampleCount);
3145#endif
3146#if ENABLE(MEDIA_STREAM)
3147static JSC_DECLARE_CUSTOM_GETTER(jsInternals_trackVideoSampleCount);
3148#endif
3149static JSC_DECLARE_CUSTOM_GETTER(jsInternals_storageAreaMapCount);
3150static JSC_DECLARE_CUSTOM_GETTER(jsInternals_processIdentifier);
3151static JSC_DECLARE_CUSTOM_GETTER(jsInternals_supportsAudioSession);
3152#if ENABLE(APPLE_PAY)
3153static JSC_DECLARE_CUSTOM_GETTER(jsInternals_mockPaymentCoordinator);
3154#endif
3155#if ENABLE(VIDEO)
3156static JSC_DECLARE_CUSTOM_GETTER(jsInternals_nowPlayingState);
3157#endif
3158#if ENABLE(VIDEO)
3159static JSC_DECLARE_CUSTOM_GETTER(jsInternals_mediaElementCount);
3160#endif
3161#if ENABLE(APP_HIGHLIGHTS)
3162static JSC_DECLARE_CUSTOM_GETTER(jsInternals_appHighlightContextMenuItemTitles);
3163#endif
3164#if ENABLE(WEBXR)
3165static JSC_DECLARE_CUSTOM_GETTER(jsInternals_xrTest);
3166#endif
3167
3168class JSInternalsPrototype final : public JSC::JSNonFinalObject {
3169public:
3170 using Base = JSC::JSNonFinalObject;
3171 static JSInternalsPrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
3172 {
3173 JSInternalsPrototype* ptr = new (NotNull, JSC::allocateCell<JSInternalsPrototype>(vm.heap)) JSInternalsPrototype(vm, globalObject, structure);
3174 ptr->finishCreation(vm);
3175 return ptr;
3176 }
3177
3178 DECLARE_INFO;
3179 template<typename CellType, JSC::SubspaceAccess>
3180 static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)
3181 {
3182 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSInternalsPrototype, Base);
3183 return &vm.plainObjectSpace;
3184 }
3185 static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
3186 {
3187 return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
3188 }
3189
3190private:
3191 JSInternalsPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
3192 : JSC::JSNonFinalObject(vm, structure)
3193 {
3194 }
3195
3196 void finishCreation(JSC::VM&);
3197public:
3198 static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::HasStaticPropertyTable;
3199};
3200STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSInternalsPrototype, JSInternalsPrototype::Base);
3201
3202/* Hash table for Prototype */
3203
3204static const struct CompactHashIndex JSInternalsPrototypeTableIndex[2116] = {
3205 { -1, -1 },
3206 { -1, -1 },
3207 { -1, -1 },
3208 { -1, -1 },
3209 { -1, -1 },
3210 { 352, -1 },
3211 { -1, -1 },
3212 { 483, -1 },
3213 { 384, -1 },
3214 { -1, -1 },
3215 { -1, -1 },
3216 { -1, -1 },
3217 { -1, -1 },
3218 { -1, -1 },
3219 { -1, -1 },
3220 { 112, 2103 },
3221 { -1, -1 },
3222 { -1, -1 },
3223 { 13, 2084 },
3224 { 422, -1 },
3225 { -1, -1 },
3226 { -1, -1 },
3227 { 341, 2108 },
3228 { -1, -1 },
3229 { 518, -1 },
3230 { -1, -1 },
3231 { -1, -1 },
3232 { 93, -1 },
3233 { -1, -1 },
3234 { -1, -1 },
3235 { -1, -1 },
3236 { -1, -1 },
3237 { -1, -1 },
3238 { -1, -1 },
3239 { -1, -1 },
3240 { 137, -1 },
3241 { 8, -1 },
3242 { -1, -1 },
3243 { -1, -1 },
3244 { -1, -1 },
3245 { -1, -1 },
3246 { -1, -1 },
3247 { 98, -1 },
3248 { -1, -1 },
3249 { -1, -1 },
3250 { -1, -1 },
3251 { -1, -1 },
3252 { -1, -1 },
3253 { -1, -1 },
3254 { 245, -1 },
3255 { -1, -1 },
3256 { 279, 2104 },
3257 { 441, -1 },
3258 { 129, -1 },
3259 { -1, -1 },
3260 { -1, -1 },
3261 { -1, -1 },
3262 { 41, -1 },
3263 { 476, -1 },
3264 { 6, 2052 },
3265 { -1, -1 },
3266 { -1, -1 },
3267 { -1, -1 },
3268 { -1, -1 },
3269 { -1, -1 },
3270 { -1, -1 },
3271 { -1, -1 },
3272 { -1, -1 },
3273 { -1, -1 },
3274 { -1, -1 },
3275 { -1, -1 },
3276 { 47, -1 },
3277 { -1, -1 },
3278 { -1, -1 },
3279 { -1, -1 },
3280 { -1, -1 },
3281 { 271, -1 },
3282 { 332, -1 },
3283 { -1, -1 },
3284 { -1, -1 },
3285 { -1, -1 },
3286 { 387, -1 },
3287 { -1, -1 },
3288 { -1, -1 },
3289 { -1, -1 },
3290 { -1, -1 },
3291 { -1, -1 },
3292 { -1, -1 },
3293 { -1, -1 },
3294 { -1, -1 },
3295 { -1, -1 },
3296 { -1, -1 },
3297 { -1, -1 },
3298 { -1, -1 },
3299 { -1, -1 },
3300 { -1, -1 },
3301 { -1, -1 },
3302 { -1, -1 },
3303 { -1, -1 },
3304 { 73, -1 },
3305 { -1, -1 },
3306 { -1, -1 },
3307 { 84, -1 },
3308 { 299, -1 },
3309 { -1, -1 },
3310 { -1, -1 },
3311 { -1, -1 },
3312 { -1, -1 },
3313 { -1, -1 },
3314 { 330, -1 },
3315 { -1, -1 },
3316 { -1, -1 },
3317 { -1, -1 },
3318 { -1, -1 },
3319 { -1, -1 },
3320 { 244, -1 },
3321 { -1, -1 },
3322 { 474, -1 },
3323 { -1, -1 },
3324 { 374, -1 },
3325 { -1, -1 },
3326 { -1, -1 },
3327 { -1, -1 },
3328 { -1, -1 },
3329 { -1, -1 },
3330 { -1, -1 },
3331 { -1, -1 },
3332 { -1, -1 },
3333 { -1, -1 },
3334 { -1, -1 },
3335 { 227, -1 },
3336 { -1, -1 },
3337 { -1, -1 },
3338 { -1, -1 },
3339 { -1, -1 },
3340 { 115, -1 },
3341 { -1, -1 },
3342 { -1, -1 },
3343 { -1, -1 },
3344 { -1, -1 },
3345 { -1, -1 },
3346 { -1, -1 },
3347 { 14, 2070 },
3348 { 32, -1 },
3349 { -1, -1 },
3350 { -1, -1 },
3351 { -1, -1 },
3352 { -1, -1 },
3353 { -1, -1 },
3354 { -1, -1 },
3355 { -1, -1 },
3356 { -1, -1 },
3357 { -1, -1 },
3358 { -1, -1 },
3359 { -1, -1 },
3360 { 36, -1 },
3361 { -1, -1 },
3362 { -1, -1 },
3363 { -1, -1 },
3364 { -1, -1 },
3365 { -1, -1 },
3366 { -1, -1 },
3367 { -1, -1 },
3368 { -1, -1 },
3369 { 254, -1 },
3370 { -1, -1 },
3371 { 233, -1 },
3372 { -1, -1 },
3373 { -1, -1 },
3374 { -1, -1 },
3375 { -1, -1 },
3376 { -1, -1 },
3377 { -1, -1 },
3378 { 154, -1 },
3379 { -1, -1 },
3380 { -1, -1 },
3381 { -1, -1 },
3382 { -1, -1 },
3383 { -1, -1 },
3384 { -1, -1 },
3385 { -1, -1 },
3386 { -1, -1 },
3387 { -1, -1 },
3388 { -1, -1 },
3389 { -1, -1 },
3390 { -1, -1 },
3391 { -1, -1 },
3392 { -1, -1 },
3393 { -1, -1 },
3394 { -1, -1 },
3395 { -1, -1 },
3396 { -1, -1 },
3397 { -1, -1 },
3398 { 224, -1 },
3399 { -1, -1 },
3400 { -1, -1 },
3401 { -1, -1 },
3402 { -1, -1 },
3403 { 504, -1 },
3404 { -1, -1 },
3405 { 432, -1 },
3406 { 37, 2095 },
3407 { 416, -1 },
3408 { -1, -1 },
3409 { -1, -1 },
3410 { -1, -1 },
3411 { -1, -1 },
3412 { -1, -1 },
3413 { -1, -1 },
3414 { -1, -1 },
3415 { 436, -1 },
3416 { -1, -1 },
3417 { -1, -1 },
3418 { -1, -1 },
3419 { -1, -1 },
3420 { -1, -1 },
3421 { -1, -1 },
3422 { -1, -1 },
3423 { -1, -1 },
3424 { -1, -1 },
3425 { -1, -1 },
3426 { 294, -1 },
3427 { -1, -1 },
3428 { 114, -1 },
3429 { -1, -1 },
3430 { 203, -1 },
3431 { -1, -1 },
3432 { -1, -1 },
3433 { -1, -1 },
3434 { 508, -1 },
3435 { -1, -1 },
3436 { -1, -1 },
3437 { 156, -1 },
3438 { 521, -1 },
3439 { 514, -1 },
3440 { -1, -1 },
3441 { -1, -1 },
3442 { -1, -1 },
3443 { -1, -1 },
3444 { -1, -1 },
3445 { -1, -1 },
3446 { 45, -1 },
3447 { -1, -1 },
3448 { -1, -1 },
3449 { -1, -1 },
3450 { -1, -1 },
3451 { 377, -1 },
3452 { -1, -1 },
3453 { -1, -1 },
3454 { -1, -1 },
3455 { 517, -1 },
3456 { -1, -1 },
3457 { -1, -1 },
3458 { -1, -1 },
3459 { -1, -1 },
3460 { -1, -1 },
3461 { -1, -1 },
3462 { -1, -1 },
3463 { 475, -1 },
3464 { -1, -1 },
3465 { -1, -1 },
3466 { 106, -1 },
3467 { -1, -1 },
3468 { -1, -1 },
3469 { 95, 2053 },
3470 { -1, -1 },
3471 { -1, -1 },
3472 { -1, -1 },
3473 { -1, -1 },
3474 { -1, -1 },
3475 { -1, -1 },
3476 { -1, -1 },
3477 { -1, -1 },
3478 { -1, -1 },
3479 { 113, -1 },
3480 { 63, -1 },
3481 { -1, -1 },
3482 { 424, -1 },
3483 { -1, -1 },
3484 { -1, -1 },
3485 { -1, -1 },
3486 { -1, -1 },
3487 { 118, -1 },
3488 { 418, -1 },
3489 { -1, -1 },
3490 { -1, -1 },
3491 { -1, -1 },
3492 { -1, -1 },
3493 { -1, -1 },
3494 { -1, -1 },
3495 { 442, -1 },
3496 { -1, -1 },
3497 { -1, -1 },
3498 { -1, -1 },
3499 { -1, -1 },
3500 { -1, -1 },
3501 { -1, -1 },
3502 { -1, -1 },
3503 { 452, -1 },
3504 { -1, -1 },
3505 { -1, -1 },
3506 { -1, -1 },
3507 { -1, -1 },
3508 { -1, -1 },
3509 { 281, -1 },
3510 { -1, -1 },
3511 { 389, -1 },
3512 { -1, -1 },
3513 { -1, -1 },
3514 { -1, -1 },
3515 { -1, -1 },
3516 { -1, -1 },
3517 { -1, -1 },
3518 { -1, -1 },
3519 { -1, -1 },
3520 { -1, -1 },
3521 { -1, -1 },
3522 { -1, -1 },
3523 { -1, -1 },
3524 { -1, -1 },
3525 { -1, -1 },
3526 { -1, -1 },
3527 { -1, -1 },
3528 { 5, -1 },
3529 { 147, -1 },
3530 { -1, -1 },
3531 { -1, -1 },
3532 { -1, -1 },
3533 { -1, -1 },
3534 { -1, -1 },
3535 { -1, -1 },
3536 { -1, -1 },
3537 { -1, -1 },
3538 { 307, -1 },
3539 { -1, -1 },
3540 { -1, -1 },
3541 { 208, -1 },
3542 { -1, -1 },
3543 { -1, -1 },
3544 { -1, -1 },
3545 { -1, -1 },
3546 { -1, -1 },
3547 { -1, -1 },
3548 { -1, -1 },
3549 { -1, -1 },
3550 { -1, -1 },
3551 { -1, -1 },
3552 { -1, -1 },
3553 { -1, -1 },
3554 { -1, -1 },
3555 { -1, -1 },
3556 { -1, -1 },
3557 { -1, -1 },
3558 { -1, -1 },
3559 { -1, -1 },
3560 { 278, -1 },
3561 { -1, -1 },
3562 { 349, 2111 },
3563 { 506, -1 },
3564 { 102, -1 },
3565 { -1, -1 },
3566 { -1, -1 },
3567 { -1, -1 },
3568 { -1, -1 },
3569 { -1, -1 },
3570 { -1, -1 },
3571 { -1, -1 },
3572 { -1, -1 },
3573 { -1, -1 },
3574 { -1, -1 },
3575 { -1, -1 },
3576 { -1, -1 },
3577 { -1, -1 },
3578 { -1, -1 },
3579 { -1, -1 },
3580 { -1, -1 },
3581 { -1, -1 },
3582 { -1, -1 },
3583 { -1, -1 },
3584 { -1, -1 },
3585 { -1, -1 },
3586 { -1, -1 },
3587 { -1, -1 },
3588 { -1, -1 },
3589 { -1, -1 },
3590 { 209, -1 },
3591 { -1, -1 },
3592 { 499, -1 },
3593 { 139, -1 },
3594 { -1, -1 },
3595 { 138, -1 },
3596 { -1, -1 },
3597 { 210, 2057 },
3598 { -1, -1 },
3599 { -1, -1 },
3600 { 178, -1 },
3601 { -1, -1 },
3602 { -1, -1 },
3603 { -1, -1 },
3604 { -1, -1 },
3605 { 468, -1 },
3606 { -1, -1 },
3607 { 467, -1 },
3608 { -1, -1 },
3609 { -1, -1 },
3610 { -1, -1 },
3611 { 264, -1 },
3612 { -1, -1 },
3613 { -1, -1 },
3614 { 22, 2056 },
3615 { -1, -1 },
3616 { -1, -1 },
3617 { -1, -1 },
3618 { -1, -1 },
3619 { -1, -1 },
3620 { 38, 2049 },
3621 { 161, 2115 },
3622 { -1, -1 },
3623 { -1, -1 },
3624 { -1, -1 },
3625 { -1, -1 },
3626 { -1, -1 },
3627 { -1, -1 },
3628 { 465, 2106 },
3629 { 4, 2058 },
3630 { -1, -1 },
3631 { -1, -1 },
3632 { 166, -1 },
3633 { -1, -1 },
3634 { 194, -1 },
3635 { -1, -1 },
3636 { -1, -1 },
3637 { -1, -1 },
3638 { -1, -1 },
3639 { 360, -1 },
3640 { 507, -1 },
3641 { 77, -1 },
3642 { 108, -1 },
3643 { 75, -1 },
3644 { -1, -1 },
3645 { -1, -1 },
3646 { -1, -1 },
3647 { -1, -1 },
3648 { -1, -1 },
3649 { -1, -1 },
3650 { 322, -1 },
3651 { -1, -1 },
3652 { -1, -1 },
3653 { 469, -1 },
3654 { -1, -1 },
3655 { -1, -1 },
3656 { -1, -1 },
3657 { -1, -1 },
3658 { -1, -1 },
3659 { -1, -1 },
3660 { 153, 2064 },
3661 { -1, -1 },
3662 { -1, -1 },
3663 { 19, -1 },
3664 { -1, -1 },
3665 { -1, -1 },
3666 { -1, -1 },
3667 { -1, -1 },
3668 { -1, -1 },
3669 { -1, -1 },
3670 { -1, -1 },
3671 { -1, -1 },
3672 { -1, -1 },
3673 { -1, -1 },
3674 { -1, -1 },
3675 { -1, -1 },
3676 { -1, -1 },
3677 { -1, -1 },
3678 { -1, -1 },
3679 { -1, -1 },
3680 { -1, -1 },
3681 { -1, -1 },
3682 { -1, -1 },
3683 { -1, -1 },
3684 { -1, -1 },
3685 { -1, -1 },
3686 { 82, 2079 },
3687 { -1, -1 },
3688 { -1, -1 },
3689 { -1, -1 },
3690 { -1, -1 },
3691 { 274, 2092 },
3692 { 250, -1 },
3693 { -1, -1 },
3694 { -1, -1 },
3695 { -1, -1 },
3696 { 276, -1 },
3697 { -1, -1 },
3698 { -1, -1 },
3699 { -1, -1 },
3700 { 151, 2069 },
3701 { -1, -1 },
3702 { -1, -1 },
3703 { -1, -1 },
3704 { -1, -1 },
3705 { -1, -1 },
3706 { -1, -1 },
3707 { -1, -1 },
3708 { -1, -1 },
3709 { -1, -1 },
3710 { 123, -1 },
3711 { -1, -1 },
3712 { -1, -1 },
3713 { -1, -1 },
3714 { -1, -1 },
3715 { -1, -1 },
3716 { -1, -1 },
3717 { 404, 2096 },
3718 { -1, -1 },
3719 { 413, -1 },
3720 { -1, -1 },
3721 { -1, -1 },
3722 { -1, -1 },
3723 { -1, -1 },
3724 { 478, -1 },
3725 { -1, -1 },
3726 { 462, -1 },
3727 { -1, -1 },
3728 { -1, -1 },
3729 { 253, -1 },
3730 { -1, -1 },
3731 { -1, -1 },
3732 { -1, -1 },
3733 { 417, -1 },
3734 { -1, -1 },
3735 { 402, -1 },
3736 { 31, -1 },
3737 { -1, -1 },
3738 { -1, -1 },
3739 { -1, -1 },
3740 { -1, -1 },
3741 { 164, -1 },
3742 { -1, -1 },
3743 { -1, -1 },
3744 { -1, -1 },
3745 { -1, -1 },
3746 { -1, -1 },
3747 { 289, -1 },
3748 { -1, -1 },
3749 { -1, -1 },
3750 { 291, -1 },
3751 { -1, -1 },
3752 { 169, -1 },
3753 { -1, -1 },
3754 { -1, -1 },
3755 { -1, -1 },
3756 { -1, -1 },
3757 { 460, -1 },
3758 { -1, -1 },
3759 { -1, -1 },
3760 { -1, -1 },
3761 { 247, -1 },
3762 { -1, -1 },
3763 { -1, -1 },
3764 { -1, -1 },
3765 { -1, -1 },
3766 { -1, -1 },
3767 { 447, -1 },
3768 { 122, -1 },
3769 { -1, -1 },
3770 { -1, -1 },
3771 { 72, -1 },
3772 { 301, -1 },
3773 { -1, -1 },
3774 { -1, -1 },
3775 { 90, -1 },
3776 { 148, -1 },
3777 { -1, -1 },
3778 { 359, -1 },
3779 { -1, -1 },
3780 { -1, -1 },
3781 { -1, -1 },
3782 { -1, -1 },
3783 { -1, -1 },
3784 { 357, -1 },
3785 { -1, -1 },
3786 { -1, -1 },
3787 { 213, 2086 },
3788 { -1, -1 },
3789 { -1, -1 },
3790 { -1, -1 },
3791 { -1, -1 },
3792 { -1, -1 },
3793 { -1, -1 },
3794 { 172, -1 },
3795 { -1, -1 },
3796 { 170, -1 },
3797 { -1, -1 },
3798 { -1, -1 },
3799 { -1, -1 },
3800 { -1, -1 },
3801 { -1, -1 },
3802 { -1, -1 },
3803 { -1, -1 },
3804 { -1, -1 },
3805 { 316, -1 },
3806 { 162, 2077 },
3807 { -1, -1 },
3808 { 241, -1 },
3809 { -1, -1 },
3810 { 437, -1 },
3811 { -1, -1 },
3812 { -1, -1 },
3813 { -1, -1 },
3814 { 219, -1 },
3815 { -1, -1 },
3816 { -1, -1 },
3817 { -1, -1 },
3818 { -1, -1 },
3819 { 191, -1 },
3820 { -1, -1 },
3821 { -1, -1 },
3822 { -1, -1 },
3823 { -1, -1 },
3824 { -1, -1 },
3825 { -1, -1 },
3826 { -1, -1 },
3827 { -1, -1 },
3828 { -1, -1 },
3829 { -1, -1 },
3830 { -1, -1 },
3831 { -1, -1 },
3832 { -1, -1 },
3833 { -1, -1 },
3834 { -1, -1 },
3835 { 9, -1 },
3836 { -1, -1 },
3837 { -1, -1 },
3838 { -1, -1 },
3839 { -1, -1 },
3840 { -1, -1 },
3841 { -1, -1 },
3842 { -1, -1 },
3843 { -1, -1 },
3844 { -1, -1 },
3845 { 265, -1 },
3846 { -1, -1 },
3847 { 297, -1 },
3848 { -1, -1 },
3849 { -1, -1 },
3850 { -1, -1 },
3851 { 305, -1 },
3852 { -1, -1 },
3853 { -1, -1 },
3854 { -1, -1 },
3855 { -1, -1 },
3856 { -1, -1 },
3857 { -1, -1 },
3858 { 365, -1 },
3859 { -1, -1 },
3860 { -1, -1 },
3861 { 81, -1 },
3862 { -1, -1 },
3863 { -1, -1 },
3864 { 259, -1 },
3865 { -1, -1 },
3866 { 495, -1 },
3867 { -1, -1 },
3868 { -1, -1 },
3869 { -1, -1 },
3870 { -1, -1 },
3871 { -1, -1 },
3872 { 211, -1 },
3873 { -1, -1 },
3874 { -1, -1 },
3875 { -1, -1 },
3876 { -1, -1 },
3877 { -1, -1 },
3878 { -1, -1 },
3879 { -1, -1 },
3880 { 126, 2062 },
3881 { -1, -1 },
3882 { -1, -1 },
3883 { -1, -1 },
3884 { -1, -1 },
3885 { -1, -1 },
3886 { -1, -1 },
3887 { -1, -1 },
3888 { -1, -1 },
3889 { -1, -1 },
3890 { -1, -1 },
3891 { -1, -1 },
3892 { -1, -1 },
3893 { -1, -1 },
3894 { -1, -1 },
3895 { -1, -1 },
3896 { -1, -1 },
3897 { -1, -1 },
3898 { -1, -1 },
3899 { -1, -1 },
3900 { -1, -1 },
3901 { -1, -1 },
3902 { -1, -1 },
3903 { -1, -1 },
3904 { -1, -1 },
3905 { -1, -1 },
3906 { -1, -1 },
3907 { -1, -1 },
3908 { -1, -1 },
3909 { -1, -1 },
3910 { -1, -1 },
3911 { -1, -1 },
3912 { 218, 2082 },
3913 { -1, -1 },
3914 { -1, -1 },
3915 { -1, -1 },
3916 { -1, -1 },
3917 { 222, -1 },
3918 { -1, -1 },
3919 { 334, -1 },
3920 { -1, -1 },
3921 { -1, -1 },
3922 { 183, -1 },
3923 { -1, -1 },
3924 { -1, -1 },
3925 { -1, -1 },
3926 { -1, -1 },
3927 { -1, -1 },
3928 { -1, -1 },
3929 { 333, -1 },
3930 { -1, -1 },
3931 { -1, -1 },
3932 { -1, -1 },
3933 { -1, -1 },
3934 { 379, -1 },
3935 { -1, -1 },
3936 { -1, -1 },
3937 { -1, -1 },
3938 { -1, -1 },
3939 { 376, -1 },
3940 { -1, -1 },
3941 { -1, -1 },
3942 { -1, -1 },
3943 { -1, -1 },
3944 { -1, -1 },
3945 { 2, -1 },
3946 { -1, -1 },
3947 { 368, -1 },
3948 { -1, -1 },
3949 { -1, -1 },
3950 { 461, -1 },
3951 { -1, -1 },
3952 { 505, -1 },
3953 { 135, 2072 },
3954 { -1, -1 },
3955 { -1, -1 },
3956 { 91, -1 },
3957 { 306, -1 },
3958 { -1, -1 },
3959 { -1, -1 },
3960 { -1, -1 },
3961 { -1, -1 },
3962 { 16, 2074 },
3963 { -1, -1 },
3964 { 97, -1 },
3965 { -1, -1 },
3966 { 120, -1 },
3967 { -1, -1 },
3968 { 463, 2110 },
3969 { -1, -1 },
3970 { -1, -1 },
3971 { -1, -1 },
3972 { 353, -1 },
3973 { -1, -1 },
3974 { -1, -1 },
3975 { -1, -1 },
3976 { -1, -1 },
3977 { 500, -1 },
3978 { -1, -1 },
3979 { -1, -1 },
3980 { -1, -1 },
3981 { -1, -1 },
3982 { -1, -1 },
3983 { -1, -1 },
3984 { -1, -1 },
3985 { -1, -1 },
3986 { -1, -1 },
3987 { -1, -1 },
3988 { 28, 2054 },
3989 { -1, -1 },
3990 { -1, -1 },
3991 { -1, -1 },
3992 { -1, -1 },
3993 { -1, -1 },
3994 { -1, -1 },
3995 { 220, -1 },
3996 { -1, -1 },
3997 { -1, -1 },
3998 { 125, 2061 },
3999 { 285, -1 },
4000 { -1, -1 },
4001 { -1, -1 },
4002 { -1, -1 },
4003 { -1, -1 },
4004 { -1, -1 },
4005 { -1, -1 },
4006 { -1, -1 },
4007 { 252, -1 },
4008 { -1, -1 },
4009 { -1, -1 },
4010 { 367, -1 },
4011 { -1, -1 },
4012 { -1, -1 },
4013 { -1, -1 },
4014 { -1, -1 },
4015 { -1, -1 },
4016 { -1, -1 },
4017 { -1, -1 },
4018 { -1, -1 },
4019 { -1, -1 },
4020 { -1, -1 },
4021 { -1, -1 },
4022 { -1, -1 },
4023 { -1, -1 },
4024 { 256, 2065 },
4025 { -1, -1 },
4026 { -1, -1 },
4027 { -1, -1 },
4028 { 179, -1 },
4029 { 74, -1 },
4030 { 510, -1 },
4031 { 205, -1 },
4032 { -1, -1 },
4033 { -1, -1 },
4034 { -1, -1 },
4035 { -1, -1 },
4036 { -1, -1 },
4037 { -1, -1 },
4038 { -1, -1 },
4039 { -1, -1 },
4040 { 128, -1 },
4041 { -1, -1 },
4042 { -1, -1 },
4043 { 513, -1 },
4044 { -1, -1 },
4045 { 298, -1 },
4046 { -1, -1 },
4047 { -1, -1 },
4048 { -1, -1 },
4049 { -1, -1 },
4050 { -1, -1 },
4051 { -1, -1 },
4052 { -1, -1 },
4053 { -1, -1 },
4054 { 386, -1 },
4055 { -1, -1 },
4056 { -1, -1 },
4057 { -1, -1 },
4058 { -1, -1 },
4059 { -1, -1 },
4060 { -1, -1 },
4061 { -1, -1 },
4062 { 7, -1 },
4063 { -1, -1 },
4064 { -1, -1 },
4065 { -1, -1 },
4066 { 448, -1 },
4067 { 24, -1 },
4068 { -1, -1 },
4069 { 326, -1 },
4070 { -1, -1 },
4071 { -1, -1 },
4072 { -1, -1 },
4073 { -1, -1 },
4074 { 394, -1 },
4075 { -1, -1 },
4076 { -1, -1 },
4077 { -1, -1 },
4078 { -1, -1 },
4079 { -1, -1 },
4080 { 315, -1 },
4081 { -1, -1 },
4082 { -1, -1 },
4083 { 282, -1 },
4084 { -1, -1 },
4085 { -1, -1 },
4086 { -1, -1 },
4087 { 318, -1 },
4088 { 347, -1 },
4089 { -1, -1 },
4090 { -1, -1 },
4091 { -1, -1 },
4092 { -1, -1 },
4093 { 512, -1 },
4094 { -1, -1 },
4095 { 235, 2088 },
4096 { -1, -1 },
4097 { -1, -1 },
4098 { -1, -1 },
4099 { -1, -1 },
4100 { 269, -1 },
4101 { -1, -1 },
4102 { -1, -1 },
4103 { -1, -1 },
4104 { -1, -1 },
4105 { -1, -1 },
4106 { -1, -1 },
4107 { -1, -1 },
4108 { -1, -1 },
4109 { 428, -1 },
4110 { 167, -1 },
4111 { -1, -1 },
4112 { -1, -1 },
4113 { 290, -1 },
4114 { -1, -1 },
4115 { -1, -1 },
4116 { -1, -1 },
4117 { 189, -1 },
4118 { 88, -1 },
4119 { 381, -1 },
4120 { 260, -1 },
4121 { -1, -1 },
4122 { -1, -1 },
4123 { -1, -1 },
4124 { 421, -1 },
4125 { -1, -1 },
4126 { 43, -1 },
4127 { -1, -1 },
4128 { -1, -1 },
4129 { -1, -1 },
4130 { -1, -1 },
4131 { -1, -1 },
4132 { -1, -1 },
4133 { 232, 2067 },
4134 { -1, -1 },
4135 { -1, -1 },
4136 { -1, -1 },
4137 { -1, -1 },
4138 { -1, -1 },
4139 { -1, -1 },
4140 { -1, -1 },
4141 { -1, -1 },
4142 { -1, -1 },
4143 { 39, -1 },
4144 { -1, -1 },
4145 { -1, -1 },
4146 { -1, -1 },
4147 { -1, -1 },
4148 { 146, -1 },
4149 { 134, -1 },
4150 { -1, -1 },
4151 { -1, -1 },
4152 { 292, -1 },
4153 { -1, -1 },
4154 { -1, -1 },
4155 { 27, -1 },
4156 { -1, -1 },
4157 { -1, -1 },
4158 { -1, -1 },
4159 { -1, -1 },
4160 { 481, -1 },
4161 { -1, -1 },
4162 { -1, -1 },
4163 { -1, -1 },
4164 { -1, -1 },
4165 { -1, -1 },
4166 { -1, -1 },
4167 { 21, -1 },
4168 { -1, -1 },
4169 { -1, -1 },
4170 { -1, -1 },
4171 { -1, -1 },
4172 { -1, -1 },
4173 { 124, -1 },
4174 { -1, -1 },
4175 { -1, -1 },
4176 { -1, -1 },
4177 { -1, -1 },
4178 { -1, -1 },
4179 { 407, -1 },
4180 { -1, -1 },
4181 { 497, -1 },
4182 { 355, -1 },
4183 { -1, -1 },
4184 { -1, -1 },
4185 { 197, -1 },
4186 { 130, -1 },
4187 { -1, -1 },
4188 { -1, -1 },
4189 { -1, -1 },
4190 { -1, -1 },
4191 { -1, -1 },
4192 { -1, -1 },
4193 { 335, 2097 },
4194 { 451, -1 },
4195 { -1, -1 },
4196 { -1, -1 },
4197 { -1, -1 },
4198 { -1, -1 },
4199 { 415, -1 },
4200 { 331, -1 },
4201 { -1, -1 },
4202 { -1, -1 },
4203 { -1, -1 },
4204 { -1, -1 },
4205 { -1, -1 },
4206 { 52, -1 },
4207 { -1, -1 },
4208 { -1, -1 },
4209 { 401, 2093 },
4210 { -1, -1 },
4211 { 321, -1 },
4212 { -1, -1 },
4213 { -1, -1 },
4214 { -1, -1 },
4215 { -1, -1 },
4216 { -1, -1 },
4217 { -1, -1 },
4218 { 145, -1 },
4219 { 425, -1 },
4220 { -1, -1 },
4221 { -1, -1 },
4222 { 396, -1 },
4223 { 257, 2078 },
4224 { -1, -1 },
4225 { -1, -1 },
4226 { -1, -1 },
4227 { -1, -1 },
4228 { 85, -1 },
4229 { -1, -1 },
4230 { -1, -1 },
4231 { -1, -1 },
4232 { -1, -1 },
4233 { -1, -1 },
4234 { -1, -1 },
4235 { -1, -1 },
4236 { 68, -1 },
4237 { -1, -1 },
4238 { -1, -1 },
4239 { -1, -1 },
4240 { -1, -1 },
4241 { 490, -1 },
4242 { -1, -1 },
4243 { -1, -1 },
4244 { -1, -1 },
4245 { -1, -1 },
4246 { 303, 2085 },
4247 { 378, -1 },
4248 { -1, -1 },
4249 { 29, -1 },
4250 { -1, -1 },
4251 { 198, -1 },
4252 { -1, -1 },
4253 { -1, -1 },
4254 { -1, -1 },
4255 { -1, -1 },
4256 { -1, -1 },
4257 { 104, -1 },
4258 { -1, -1 },
4259 { -1, -1 },
4260 { -1, -1 },
4261 { 412, -1 },
4262 { -1, -1 },
4263 { -1, -1 },
4264 { 80, -1 },
4265 { -1, -1 },
4266 { -1, -1 },
4267 { 449, -1 },
4268 { -1, -1 },
4269 { -1, -1 },
4270 { 182, -1 },
4271 { -1, -1 },
4272 { 83, -1 },
4273 { -1, -1 },
4274 { -1, -1 },
4275 { 67, 2109 },
4276 { -1, -1 },
4277 { -1, -1 },
4278 { 70, 2080 },
4279 { -1, -1 },
4280 { -1, -1 },
4281 { -1, -1 },
4282 { 229, -1 },
4283 { 351, -1 },
4284 { -1, -1 },
4285 { -1, -1 },
4286 { 180, -1 },
4287 { -1, -1 },
4288 { -1, -1 },
4289 { -1, -1 },
4290 { -1, -1 },
4291 { -1, -1 },
4292 { -1, -1 },
4293 { -1, -1 },
4294 { -1, -1 },
4295 { 444, -1 },
4296 { -1, -1 },
4297 { 433, -1 },
4298 { -1, -1 },
4299 { -1, -1 },
4300 { 240, -1 },
4301 { -1, -1 },
4302 { -1, -1 },
4303 { -1, -1 },
4304 { -1, -1 },
4305 { -1, -1 },
4306 { -1, -1 },
4307 { -1, -1 },
4308 { -1, -1 },
4309 { -1, -1 },
4310 { -1, -1 },
4311 { -1, -1 },
4312 { -1, -1 },
4313 { -1, -1 },
4314 { -1, -1 },
4315 { 150, 2090 },
4316 { -1, -1 },
4317 { -1, -1 },
4318 { 399, -1 },
4319 { -1, -1 },
4320 { -1, -1 },
4321 { 206, -1 },
4322 { -1, -1 },
4323 { -1, -1 },
4324 { -1, -1 },
4325 { -1, -1 },
4326 { -1, -1 },
4327 { 266, -1 },
4328 { -1, -1 },
4329 { -1, -1 },
4330 { -1, -1 },
4331 { 502, -1 },
4332 { -1, -1 },
4333 { -1, -1 },
4334 { 65, -1 },
4335 { -1, -1 },
4336 { -1, -1 },
4337 { -1, -1 },
4338 { 430, -1 },
4339 { -1, -1 },
4340 { 44, -1 },
4341 { -1, -1 },
4342 { 496, -1 },
4343 { -1, -1 },
4344 { 188, -1 },
4345 { -1, -1 },
4346 { -1, -1 },
4347 { -1, -1 },
4348 { -1, -1 },
4349 { -1, -1 },
4350 { 380, -1 },
4351 { -1, -1 },
4352 { -1, -1 },
4353 { -1, -1 },
4354 { -1, -1 },
4355 { -1, -1 },
4356 { -1, -1 },
4357 { -1, -1 },
4358 { -1, -1 },
4359 { -1, -1 },
4360 { -1, -1 },
4361 { -1, -1 },
4362 { -1, -1 },
4363 { -1, -1 },
4364 { -1, -1 },
4365 { 152, -1 },
4366 { -1, -1 },
4367 { -1, -1 },
4368 { -1, -1 },
4369 { -1, -1 },
4370 { -1, -1 },
4371 { 50, -1 },
4372 { -1, -1 },
4373 { -1, -1 },
4374 { -1, -1 },
4375 { -1, -1 },
4376 { -1, -1 },
4377 { -1, -1 },
4378 { -1, -1 },
4379 { -1, -1 },
4380 { -1, -1 },
4381 { -1, -1 },
4382 { -1, -1 },
4383 { 302, -1 },
4384 { -1, -1 },
4385 { 251, -1 },
4386 { 42, 2048 },
4387 { -1, -1 },
4388 { -1, -1 },
4389 { 144, -1 },
4390 { -1, -1 },
4391 { -1, -1 },
4392 { -1, -1 },
4393 { -1, -1 },
4394 { -1, -1 },
4395 { 192, -1 },
4396 { -1, -1 },
4397 { -1, -1 },
4398 { -1, -1 },
4399 { -1, -1 },
4400 { 383, -1 },
4401 { -1, -1 },
4402 { -1, -1 },
4403 { -1, -1 },
4404 { 12, -1 },
4405 { 59, -1 },
4406 { -1, -1 },
4407 { 64, -1 },
4408 { -1, -1 },
4409 { -1, -1 },
4410 { -1, -1 },
4411 { -1, -1 },
4412 { -1, -1 },
4413 { -1, -1 },
4414 { -1, -1 },
4415 { -1, -1 },
4416 { -1, -1 },
4417 { -1, -1 },
4418 { -1, -1 },
4419 { -1, -1 },
4420 { -1, -1 },
4421 { 443, -1 },
4422 { -1, -1 },
4423 { 34, -1 },
4424 { -1, -1 },
4425 { -1, -1 },
4426 { 159, -1 },
4427 { 111, -1 },
4428 { 149, -1 },
4429 { 142, -1 },
4430 { 280, -1 },
4431 { -1, -1 },
4432 { -1, -1 },
4433 { 487, -1 },
4434 { -1, -1 },
4435 { -1, -1 },
4436 { -1, -1 },
4437 { -1, -1 },
4438 { -1, -1 },
4439 { 136, -1 },
4440 { 133, -1 },
4441 { -1, -1 },
4442 { 284, 2089 },
4443 { -1, -1 },
4444 { -1, -1 },
4445 { -1, -1 },
4446 { -1, -1 },
4447 { -1, -1 },
4448 { -1, -1 },
4449 { -1, -1 },
4450 { -1, -1 },
4451 { -1, -1 },
4452 { 408, -1 },
4453 { -1, -1 },
4454 { -1, -1 },
4455 { -1, -1 },
4456 { -1, -1 },
4457 { -1, -1 },
4458 { -1, -1 },
4459 { -1, -1 },
4460 { -1, -1 },
4461 { -1, -1 },
4462 { -1, -1 },
4463 { -1, -1 },
4464 { -1, -1 },
4465 { -1, -1 },
4466 { -1, -1 },
4467 { -1, -1 },
4468 { -1, -1 },
4469 { -1, -1 },
4470 { -1, -1 },
4471 { -1, -1 },
4472 { -1, -1 },
4473 { -1, -1 },
4474 { 464, -1 },
4475 { -1, -1 },
4476 { 143, -1 },
4477 { 3, -1 },
4478 { -1, -1 },
4479 { -1, -1 },
4480 { 214, -1 },
4481 { -1, -1 },
4482 { -1, -1 },
4483 { 132, -1 },
4484 { -1, -1 },
4485 { -1, -1 },
4486 { -1, -1 },
4487 { -1, -1 },
4488 { 243, 2068 },
4489 { -1, -1 },
4490 { -1, -1 },
4491 { -1, -1 },
4492 { -1, -1 },
4493 { -1, -1 },
4494 { -1, -1 },
4495 { -1, -1 },
4496 { -1, -1 },
4497 { 35, -1 },
4498 { -1, -1 },
4499 { -1, -1 },
4500 { -1, -1 },
4501 { -1, -1 },
4502 { -1, -1 },
4503 { -1, -1 },
4504 { -1, -1 },
4505 { -1, -1 },
4506 { -1, -1 },
4507 { -1, -1 },
4508 { -1, -1 },
4509 { -1, -1 },
4510 { -1, -1 },
4511 { -1, -1 },
4512 { 480, 2112 },
4513 { -1, -1 },
4514 { -1, -1 },
4515 { 49, 2059 },
4516 { 30, -1 },
4517 { 320, -1 },
4518 { 157, -1 },
4519 { -1, -1 },
4520 { -1, -1 },
4521 { -1, -1 },
4522 { -1, -1 },
4523 { 391, -1 },
4524 { -1, -1 },
4525 { -1, -1 },
4526 { -1, -1 },
4527 { 373, -1 },
4528 { -1, -1 },
4529 { -1, -1 },
4530 { -1, -1 },
4531 { -1, -1 },
4532 { -1, -1 },
4533 { -1, -1 },
4534 { -1, -1 },
4535 { -1, -1 },
4536 { 339, -1 },
4537 { -1, -1 },
4538 { 492, -1 },
4539 { -1, -1 },
4540 { -1, -1 },
4541 { -1, -1 },
4542 { -1, -1 },
4543 { -1, -1 },
4544 { -1, -1 },
4545 { -1, -1 },
4546 { 348, -1 },
4547 { 388, -1 },
4548 { 286, -1 },
4549 { -1, -1 },
4550 { -1, -1 },
4551 { 23, 2114 },
4552 { -1, -1 },
4553 { -1, -1 },
4554 { -1, -1 },
4555 { -1, -1 },
4556 { -1, -1 },
4557 { 58, -1 },
4558 { -1, -1 },
4559 { -1, -1 },
4560 { -1, -1 },
4561 { -1, -1 },
4562 { -1, -1 },
4563 { -1, -1 },
4564 { -1, -1 },
4565 { 79, -1 },
4566 { -1, -1 },
4567 { -1, -1 },
4568 { -1, -1 },
4569 { -1, -1 },
4570 { -1, -1 },
4571 { -1, -1 },
4572 { -1, -1 },
4573 { -1, -1 },
4574 { -1, -1 },
4575 { -1, -1 },
4576 { 395, -1 },
4577 { -1, -1 },
4578 { -1, -1 },
4579 { -1, -1 },
4580 { 185, 2094 },
4581 { -1, -1 },
4582 { 338, -1 },
4583 { 372, 2083 },
4584 { -1, -1 },
4585 { -1, -1 },
4586 { -1, -1 },
4587 { -1, -1 },
4588 { -1, -1 },
4589 { -1, -1 },
4590 { -1, -1 },
4591 { -1, -1 },
4592 { -1, -1 },
4593 { -1, -1 },
4594 { -1, -1 },
4595 { -1, -1 },
4596 { -1, -1 },
4597 { -1, -1 },
4598 { -1, -1 },
4599 { 403, -1 },
4600 { -1, -1 },
4601 { -1, -1 },
4602 { -1, -1 },
4603 { -1, -1 },
4604 { -1, -1 },
4605 { -1, -1 },
4606 { -1, -1 },
4607 { 366, -1 },
4608 { -1, -1 },
4609 { -1, -1 },
4610 { -1, -1 },
4611 { 423, -1 },
4612 { -1, -1 },
4613 { -1, -1 },
4614 { -1, -1 },
4615 { -1, -1 },
4616 { -1, -1 },
4617 { -1, -1 },
4618 { -1, -1 },
4619 { -1, -1 },
4620 { 217, -1 },
4621 { -1, -1 },
4622 { -1, -1 },
4623 { -1, -1 },
4624 { -1, -1 },
4625 { -1, -1 },
4626 { -1, -1 },
4627 { -1, -1 },
4628 { -1, -1 },
4629 { -1, -1 },
4630 { -1, -1 },
4631 { -1, -1 },
4632 { -1, -1 },
4633 { -1, -1 },
4634 { 96, -1 },
4635 { -1, -1 },
4636 { -1, -1 },
4637 { 411, -1 },
4638 { -1, -1 },
4639 { -1, -1 },
4640 { -1, -1 },
4641 { -1, -1 },
4642 { -1, -1 },
4643 { -1, -1 },
4644 { -1, -1 },
4645 { -1, -1 },
4646 { -1, -1 },
4647 { -1, -1 },
4648 { 195, -1 },
4649 { -1, -1 },
4650 { -1, -1 },
4651 { -1, -1 },
4652 { -1, -1 },
4653 { -1, -1 },
4654 { -1, -1 },
4655 { 87, -1 },
4656 { -1, -1 },
4657 { -1, -1 },
4658 { -1, -1 },
4659 { -1, -1 },
4660 { -1, -1 },
4661 { 174, -1 },
4662 { -1, -1 },
4663 { -1, -1 },
4664 { -1, -1 },
4665 { -1, -1 },
4666 { 171, -1 },
4667 { -1, -1 },
4668 { -1, -1 },
4669 { 223, 2060 },
4670 { -1, -1 },
4671 { -1, -1 },
4672 { -1, -1 },
4673 { -1, -1 },
4674 { -1, -1 },
4675 { -1, -1 },
4676 { 491, -1 },
4677 { -1, -1 },
4678 { -1, -1 },
4679 { -1, -1 },
4680 { 287, -1 },
4681 { -1, -1 },
4682 { -1, -1 },
4683 { -1, -1 },
4684 { -1, -1 },
4685 { -1, -1 },
4686 { -1, -1 },
4687 { -1, -1 },
4688 { -1, -1 },
4689 { -1, -1 },
4690 { -1, -1 },
4691 { -1, -1 },
4692 { 454, -1 },
4693 { 53, 2071 },
4694 { -1, -1 },
4695 { -1, -1 },
4696 { -1, -1 },
4697 { -1, -1 },
4698 { -1, -1 },
4699 { -1, -1 },
4700 { -1, -1 },
4701 { -1, -1 },
4702 { -1, -1 },
4703 { -1, -1 },
4704 { -1, -1 },
4705 { -1, -1 },
4706 { -1, -1 },
4707 { -1, -1 },
4708 { -1, -1 },
4709 { -1, -1 },
4710 { -1, -1 },
4711 { -1, -1 },
4712 { 420, -1 },
4713 { -1, -1 },
4714 { -1, -1 },
4715 { -1, -1 },
4716 { 60, -1 },
4717 { -1, -1 },
4718 { 1, 2050 },
4719 { -1, -1 },
4720 { 450, -1 },
4721 { -1, -1 },
4722 { -1, -1 },
4723 { -1, -1 },
4724 { 173, 2087 },
4725 { 165, -1 },
4726 { -1, -1 },
4727 { -1, -1 },
4728 { -1, -1 },
4729 { -1, -1 },
4730 { -1, -1 },
4731 { -1, -1 },
4732 { -1, -1 },
4733 { -1, -1 },
4734 { 479, -1 },
4735 { -1, -1 },
4736 { -1, -1 },
4737 { -1, -1 },
4738 { 186, -1 },
4739 { 204, -1 },
4740 { -1, -1 },
4741 { -1, -1 },
4742 { 295, -1 },
4743 { -1, -1 },
4744 { -1, -1 },
4745 { -1, -1 },
4746 { -1, -1 },
4747 { -1, -1 },
4748 { 406, -1 },
4749 { -1, -1 },
4750 { -1, -1 },
4751 { 71, -1 },
4752 { -1, -1 },
4753 { 486, -1 },
4754 { -1, -1 },
4755 { -1, -1 },
4756 { -1, -1 },
4757 { 92, 2051 },
4758 { -1, -1 },
4759 { 0, -1 },
4760 { -1, -1 },
4761 { 109, -1 },
4762 { -1, -1 },
4763 { -1, -1 },
4764 { -1, -1 },
4765 { -1, -1 },
4766 { -1, -1 },
4767 { -1, -1 },
4768 { 207, -1 },
4769 { 131, -1 },
4770 { -1, -1 },
4771 { -1, -1 },
4772 { -1, -1 },
4773 { -1, -1 },
4774 { -1, -1 },
4775 { -1, -1 },
4776 { -1, -1 },
4777 { 385, -1 },
4778 { -1, -1 },
4779 { -1, -1 },
4780 { -1, -1 },
4781 { -1, -1 },
4782 { -1, -1 },
4783 { -1, -1 },
4784 { 390, -1 },
4785 { -1, -1 },
4786 { -1, -1 },
4787 { -1, -1 },
4788 { -1, -1 },
4789 { -1, -1 },
4790 { -1, -1 },
4791 { -1, -1 },
4792 { -1, -1 },
4793 { 160, -1 },
4794 { -1, -1 },
4795 { -1, -1 },
4796 { -1, -1 },
4797 { -1, -1 },
4798 { -1, -1 },
4799 { -1, -1 },
4800 { -1, -1 },
4801 { 119, 2098 },
4802 { 103, -1 },
4803 { 354, -1 },
4804 { -1, -1 },
4805 { -1, -1 },
4806 { -1, -1 },
4807 { -1, -1 },
4808 { -1, -1 },
4809 { -1, -1 },
4810 { -1, -1 },
4811 { 293, -1 },
4812 { 158, -1 },
4813 { -1, -1 },
4814 { -1, -1 },
4815 { -1, -1 },
4816 { -1, -1 },
4817 { -1, -1 },
4818 { 231, -1 },
4819 { -1, -1 },
4820 { -1, -1 },
4821 { -1, -1 },
4822 { -1, -1 },
4823 { 288, -1 },
4824 { -1, -1 },
4825 { -1, -1 },
4826 { -1, -1 },
4827 { -1, -1 },
4828 { -1, -1 },
4829 { -1, -1 },
4830 { 364, 2107 },
4831 { 230, -1 },
4832 { -1, -1 },
4833 { -1, -1 },
4834 { -1, -1 },
4835 { -1, -1 },
4836 { -1, -1 },
4837 { 190, -1 },
4838 { 33, -1 },
4839 { -1, -1 },
4840 { -1, -1 },
4841 { -1, -1 },
4842 { 163, -1 },
4843 { 57, -1 },
4844 { 141, -1 },
4845 { -1, -1 },
4846 { -1, -1 },
4847 { -1, -1 },
4848 { -1, -1 },
4849 { 356, -1 },
4850 { -1, -1 },
4851 { -1, -1 },
4852 { -1, -1 },
4853 { 346, -1 },
4854 { -1, -1 },
4855 { -1, -1 },
4856 { 324, -1 },
4857 { 140, -1 },
4858 { -1, -1 },
4859 { -1, -1 },
4860 { -1, -1 },
4861 { -1, -1 },
4862 { -1, -1 },
4863 { 414, -1 },
4864 { -1, -1 },
4865 { -1, -1 },
4866 { -1, -1 },
4867 { -1, -1 },
4868 { -1, -1 },
4869 { -1, -1 },
4870 { -1, -1 },
4871 { 310, -1 },
4872 { -1, -1 },
4873 { -1, -1 },
4874 { -1, -1 },
4875 { -1, -1 },
4876 { -1, -1 },
4877 { -1, -1 },
4878 { -1, -1 },
4879 { -1, -1 },
4880 { -1, -1 },
4881 { -1, -1 },
4882 { -1, -1 },
4883 { 25, 2076 },
4884 { -1, -1 },
4885 { -1, -1 },
4886 { -1, -1 },
4887 { 371, -1 },
4888 { -1, -1 },
4889 { -1, -1 },
4890 { -1, -1 },
4891 { -1, -1 },
4892 { -1, -1 },
4893 { -1, -1 },
4894 { -1, -1 },
4895 { -1, -1 },
4896 { 168, -1 },
4897 { -1, -1 },
4898 { -1, -1 },
4899 { -1, -1 },
4900 { -1, -1 },
4901 { -1, -1 },
4902 { -1, -1 },
4903 { 228, -1 },
4904 { 101, -1 },
4905 { -1, -1 },
4906 { -1, -1 },
4907 { -1, -1 },
4908 { 300, -1 },
4909 { -1, -1 },
4910 { -1, -1 },
4911 { -1, -1 },
4912 { -1, -1 },
4913 { -1, -1 },
4914 { 26, -1 },
4915 { -1, -1 },
4916 { -1, -1 },
4917 { -1, -1 },
4918 { -1, -1 },
4919 { -1, -1 },
4920 { -1, -1 },
4921 { -1, -1 },
4922 { 473, -1 },
4923 { 268, -1 },
4924 { -1, -1 },
4925 { -1, -1 },
4926 { -1, -1 },
4927 { -1, -1 },
4928 { -1, -1 },
4929 { -1, -1 },
4930 { -1, -1 },
4931 { -1, -1 },
4932 { -1, -1 },
4933 { -1, -1 },
4934 { -1, -1 },
4935 { -1, -1 },
4936 { 248, -1 },
4937 { -1, -1 },
4938 { -1, -1 },
4939 { -1, -1 },
4940 { -1, -1 },
4941 { -1, -1 },
4942 { -1, -1 },
4943 { 427, -1 },
4944 { -1, -1 },
4945 { -1, -1 },
4946 { -1, -1 },
4947 { -1, -1 },
4948 { -1, -1 },
4949 { 362, -1 },
4950 { -1, -1 },
4951 { -1, -1 },
4952 { 382, -1 },
4953 { -1, -1 },
4954 { 61, -1 },
4955 { 309, -1 },
4956 { -1, -1 },
4957 { 193, -1 },
4958 { -1, -1 },
4959 { -1, -1 },
4960 { -1, -1 },
4961 { -1, -1 },
4962 { -1, -1 },
4963 { 328, -1 },
4964 { 17, -1 },
4965 { 51, -1 },
4966 { -1, -1 },
4967 { 184, -1 },
4968 { -1, -1 },
4969 { -1, -1 },
4970 { -1, -1 },
4971 { 435, -1 },
4972 { 296, -1 },
4973 { -1, -1 },
4974 { -1, -1 },
4975 { -1, -1 },
4976 { 455, -1 },
4977 { 516, -1 },
4978 { -1, -1 },
4979 { -1, -1 },
4980 { 187, -1 },
4981 { -1, -1 },
4982 { -1, -1 },
4983 { -1, -1 },
4984 { 225, -1 },
4985 { -1, -1 },
4986 { 314, 2073 },
4987 { -1, -1 },
4988 { -1, -1 },
4989 { -1, -1 },
4990 { -1, -1 },
4991 { -1, -1 },
4992 { -1, -1 },
4993 { -1, -1 },
4994 { -1, -1 },
4995 { -1, -1 },
4996 { 340, -1 },
4997 { -1, -1 },
4998 { -1, -1 },
4999 { -1, -1 },
5000 { -1, -1 },
5001 { -1, -1 },
5002 { -1, -1 },
5003 { -1, -1 },
5004 { 15, -1 },
5005 { -1, -1 },
5006 { -1, -1 },
5007 { -1, -1 },
5008 { -1, -1 },
5009 { -1, -1 },
5010 { -1, -1 },
5011 { 488, -1 },
5012 { -1, -1 },
5013 { -1, -1 },
5014 { 453, -1 },
5015 { 361, -1 },
5016 { -1, -1 },
5017 { 107, -1 },
5018 { -1, -1 },
5019 { -1, -1 },
5020 { -1, -1 },
5021 { -1, -1 },
5022 { -1, -1 },
5023 { -1, -1 },
5024 { -1, -1 },
5025 { -1, -1 },
5026 { -1, -1 },
5027 { -1, -1 },
5028 { 76, -1 },
5029 { 10, -1 },
5030 { -1, -1 },
5031 { -1, -1 },
5032 { -1, -1 },
5033 { -1, -1 },
5034 { 501, -1 },
5035 { -1, -1 },
5036 { -1, -1 },
5037 { -1, -1 },
5038 { 482, -1 },
5039 { -1, -1 },
5040 { 177, -1 },
5041 { -1, -1 },
5042 { -1, -1 },
5043 { -1, -1 },
5044 { -1, -1 },
5045 { 439, -1 },
5046 { -1, -1 },
5047 { -1, -1 },
5048 { -1, -1 },
5049 { -1, -1 },
5050 { -1, -1 },
5051 { -1, -1 },
5052 { -1, -1 },
5053 { 238, -1 },
5054 { -1, -1 },
5055 { 66, -1 },
5056 { -1, -1 },
5057 { -1, -1 },
5058 { 20, -1 },
5059 { 239, -1 },
5060 { -1, -1 },
5061 { -1, -1 },
5062 { -1, -1 },
5063 { -1, -1 },
5064 { -1, -1 },
5065 { -1, -1 },
5066 { -1, -1 },
5067 { -1, -1 },
5068 { -1, -1 },
5069 { -1, -1 },
5070 { 117, -1 },
5071 { 110, 2081 },
5072 { 11, -1 },
5073 { -1, -1 },
5074 { 18, -1 },
5075 { -1, -1 },
5076 { -1, -1 },
5077 { 215, -1 },
5078 { -1, -1 },
5079 { -1, -1 },
5080 { -1, -1 },
5081 { -1, -1 },
5082 { 56, -1 },
5083 { -1, -1 },
5084 { -1, -1 },
5085 { -1, -1 },
5086 { 262, -1 },
5087 { -1, -1 },
5088 { -1, -1 },
5089 { -1, -1 },
5090 { -1, -1 },
5091 { 226, -1 },
5092 { -1, -1 },
5093 { 312, -1 },
5094 { -1, -1 },
5095 { -1, -1 },
5096 { -1, -1 },
5097 { -1, -1 },
5098 { -1, -1 },
5099 { -1, -1 },
5100 { -1, -1 },
5101 { -1, -1 },
5102 { -1, -1 },
5103 { -1, -1 },
5104 { 221, -1 },
5105 { 375, -1 },
5106 { -1, -1 },
5107 { 212, -1 },
5108 { 175, -1 },
5109 { -1, -1 },
5110 { -1, -1 },
5111 { 199, -1 },
5112 { 255, -1 },
5113 { 55, 2101 },
5114 { -1, -1 },
5115 { 40, -1 },
5116 { -1, -1 },
5117 { -1, -1 },
5118 { -1, -1 },
5119 { -1, -1 },
5120 { -1, -1 },
5121 { -1, -1 },
5122 { 438, -1 },
5123 { -1, -1 },
5124 { -1, -1 },
5125 { -1, -1 },
5126 { -1, -1 },
5127 { 405, -1 },
5128 { -1, -1 },
5129 { 466, -1 },
5130 { -1, -1 },
5131 { -1, -1 },
5132 { -1, -1 },
5133 { 89, -1 },
5134 { -1, -1 },
5135 { -1, -1 },
5136 { -1, -1 },
5137 { 99, -1 },
5138 { -1, -1 },
5139 { 456, -1 },
5140 { 325, -1 },
5141 { -1, -1 },
5142 { -1, -1 },
5143 { -1, -1 },
5144 { 275, -1 },
5145 { -1, -1 },
5146 { -1, -1 },
5147 { -1, -1 },
5148 { -1, -1 },
5149 { -1, -1 },
5150 { 127, -1 },
5151 { -1, -1 },
5152 { 176, -1 },
5153 { 201, -1 },
5154 { 216, -1 },
5155 { -1, -1 },
5156 { -1, -1 },
5157 { -1, -1 },
5158 { -1, -1 },
5159 { -1, -1 },
5160 { -1, -1 },
5161 { -1, -1 },
5162 { -1, -1 },
5163 { -1, -1 },
5164 { -1, -1 },
5165 { 200, 2091 },
5166 { -1, -1 },
5167 { -1, -1 },
5168 { -1, -1 },
5169 { -1, -1 },
5170 { -1, -1 },
5171 { 273, -1 },
5172 { -1, -1 },
5173 { -1, -1 },
5174 { -1, -1 },
5175 { 62, -1 },
5176 { 344, -1 },
5177 { -1, -1 },
5178 { 370, -1 },
5179 { 313, -1 },
5180 { -1, -1 },
5181 { 317, -1 },
5182 { -1, -1 },
5183 { 261, -1 },
5184 { 69, -1 },
5185 { -1, -1 },
5186 { 155, -1 },
5187 { -1, -1 },
5188 { -1, -1 },
5189 { -1, -1 },
5190 { -1, -1 },
5191 { -1, -1 },
5192 { 234, -1 },
5193 { -1, -1 },
5194 { -1, -1 },
5195 { -1, -1 },
5196 { -1, -1 },
5197 { -1, -1 },
5198 { -1, -1 },
5199 { -1, -1 },
5200 { 46, -1 },
5201 { -1, -1 },
5202 { -1, -1 },
5203 { -1, -1 },
5204 { -1, -1 },
5205 { -1, -1 },
5206 { -1, -1 },
5207 { 429, -1 },
5208 { -1, -1 },
5209 { -1, -1 },
5210 { -1, -1 },
5211 { -1, -1 },
5212 { -1, -1 },
5213 { -1, -1 },
5214 { 121, -1 },
5215 { 78, 2055 },
5216 { -1, -1 },
5217 { -1, -1 },
5218 { -1, -1 },
5219 { -1, -1 },
5220 { -1, -1 },
5221 { -1, -1 },
5222 { -1, -1 },
5223 { -1, -1 },
5224 { -1, -1 },
5225 { -1, -1 },
5226 { -1, -1 },
5227 { -1, -1 },
5228 { -1, -1 },
5229 { -1, -1 },
5230 { -1, -1 },
5231 { -1, -1 },
5232 { -1, -1 },
5233 { -1, -1 },
5234 { -1, -1 },
5235 { -1, -1 },
5236 { -1, -1 },
5237 { 519, -1 },
5238 { -1, -1 },
5239 { -1, -1 },
5240 { -1, -1 },
5241 { -1, -1 },
5242 { -1, -1 },
5243 { -1, -1 },
5244 { 342, -1 },
5245 { -1, -1 },
5246 { -1, -1 },
5247 { -1, -1 },
5248 { 329, -1 },
5249 { -1, -1 },
5250 { -1, -1 },
5251 { -1, -1 },
5252 { 100, -1 },
5253 { 48, -1 },
5254 { 54, -1 },
5255 { 86, -1 },
5256 { 94, -1 },
5257 { 105, -1 },
5258 { 116, 2066 },
5259 { 181, 2100 },
5260 { 196, -1 },
5261 { 202, -1 },
5262 { 236, 2063 },
5263 { 237, 2102 },
5264 { 242, -1 },
5265 { 246, -1 },
5266 { 249, -1 },
5267 { 258, -1 },
5268 { 263, -1 },
5269 { 267, -1 },
5270 { 270, -1 },
5271 { 272, -1 },
5272 { 277, -1 },
5273 { 283, -1 },
5274 { 304, -1 },
5275 { 308, 2075 },
5276 { 311, -1 },
5277 { 319, -1 },
5278 { 323, -1 },
5279 { 327, -1 },
5280 { 336, -1 },
5281 { 337, -1 },
5282 { 343, -1 },
5283 { 345, 2099 },
5284 { 350, -1 },
5285 { 358, -1 },
5286 { 363, -1 },
5287 { 369, -1 },
5288 { 392, -1 },
5289 { 393, -1 },
5290 { 397, -1 },
5291 { 398, -1 },
5292 { 400, -1 },
5293 { 409, -1 },
5294 { 410, -1 },
5295 { 419, -1 },
5296 { 426, -1 },
5297 { 431, -1 },
5298 { 434, -1 },
5299 { 440, -1 },
5300 { 445, -1 },
5301 { 446, -1 },
5302 { 457, 2113 },
5303 { 458, -1 },
5304 { 459, -1 },
5305 { 470, -1 },
5306 { 471, -1 },
5307 { 472, 2105 },
5308 { 477, -1 },
5309 { 484, -1 },
5310 { 485, -1 },
5311 { 489, -1 },
5312 { 493, -1 },
5313 { 494, -1 },
5314 { 498, -1 },
5315 { 503, -1 },
5316 { 509, -1 },
5317 { 511, -1 },
5318 { 515, -1 },
5319 { 520, -1 },
5320 { 522, -1 },
5321};
5322
5323
5324static const HashTableValue JSInternalsPrototypeTableValues[] =
5325{
5326 { "inflightBeaconsCount", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_inflightBeaconsCount), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5327 { "animationsInterval", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_animationsInterval), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5328 { "sentenceRetroCorrectionEnabled", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_sentenceRetroCorrectionEnabled), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5329 { "settings", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_settings), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5330 { "workerThreadCount", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_workerThreadCount), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5331 { "areSVGAnimationsPaused", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_areSVGAnimationsPaused), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5332 { "isUnderMemoryPressure", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_isUnderMemoryPressure), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5333#if ENABLE(FULLSCREEN_API)
5334 { "isAnimatingFullScreen", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_isAnimatingFullScreen), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5335#else
5336 { 0, 0, NoIntrinsic, { 0, 0 } },
5337#endif
5338 { "requestAnimationFrameInterval", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_requestAnimationFrameInterval), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5339 { "scriptedAnimationsAreSuspended", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_scriptedAnimationsAreSuspended), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5340 { "eventThrottlingBehaviorOverride", JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_eventThrottlingBehaviorOverride), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSInternals_eventThrottlingBehaviorOverride) } },
5341 { "lastStyleUpdateSize", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_lastStyleUpdateSize), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5342 { "compositingPolicyOverride", JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_compositingPolicyOverride), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSInternals_compositingPolicyOverride) } },
5343 { "layoutCount", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_layoutCount), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5344#if ENABLE(CONTENT_FILTERING)
5345 { "mockContentFilterSettings", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_mockContentFilterSettings), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5346#else
5347 { 0, 0, NoIntrinsic, { 0, 0 } },
5348#endif
5349#if ENABLE(MEDIA_STREAM)
5350 { "trackAudioSampleCount", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_trackAudioSampleCount), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5351#else
5352 { 0, 0, NoIntrinsic, { 0, 0 } },
5353#endif
5354#if ENABLE(MEDIA_STREAM)
5355 { "trackVideoSampleCount", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_trackVideoSampleCount), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5356#else
5357 { 0, 0, NoIntrinsic, { 0, 0 } },
5358#endif
5359 { "storageAreaMapCount", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_storageAreaMapCount), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5360 { "processIdentifier", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_processIdentifier), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5361 { "supportsAudioSession", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_supportsAudioSession), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5362#if ENABLE(APPLE_PAY)
5363 { "mockPaymentCoordinator", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_mockPaymentCoordinator), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5364#else
5365 { 0, 0, NoIntrinsic, { 0, 0 } },
5366#endif
5367#if ENABLE(VIDEO)
5368 { "nowPlayingState", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_nowPlayingState), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5369#else
5370 { 0, 0, NoIntrinsic, { 0, 0 } },
5371#endif
5372#if ENABLE(VIDEO)
5373 { "mediaElementCount", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_mediaElementCount), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5374#else
5375 { 0, 0, NoIntrinsic, { 0, 0 } },
5376#endif
5377#if ENABLE(APP_HIGHLIGHTS)
5378 { "appHighlightContextMenuItemTitles", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_appHighlightContextMenuItemTitles), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5379#else
5380 { 0, 0, NoIntrinsic, { 0, 0 } },
5381#endif
5382#if ENABLE(WEBXR)
5383 { "xrTest", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternals_xrTest), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
5384#else
5385 { 0, 0, NoIntrinsic, { 0, 0 } },
5386#endif
5387 { "address", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_address), (intptr_t) (1) } },
5388 { "nodeNeedsStyleRecalc", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_nodeNeedsStyleRecalc), (intptr_t) (1) } },
5389 { "styleChangeType", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_styleChangeType), (intptr_t) (1) } },
5390 { "description", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_description), (intptr_t) (1) } },
5391 { "log", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_log), (intptr_t) (1) } },
5392 { "hasPausedImageAnimations", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_hasPausedImageAnimations), (intptr_t) (1) } },
5393 { "isPaintingFrequently", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isPaintingFrequently), (intptr_t) (1) } },
5394 { "incrementFrequentPaintCounter", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_incrementFrequentPaintCounter), (intptr_t) (1) } },
5395 { "elementRenderTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_elementRenderTreeAsText), (intptr_t) (1) } },
5396 { "isPreloaded", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isPreloaded), (intptr_t) (1) } },
5397 { "isLoadingFromMemoryCache", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isLoadingFromMemoryCache), (intptr_t) (1) } },
5398 { "fetchResponseSource", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_fetchResponseSource), (intptr_t) (1) } },
5399 { "xhrResponseSource", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_xhrResponseSource), (intptr_t) (1) } },
5400 { "isSharingStyleSheetContents", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isSharingStyleSheetContents), (intptr_t) (2) } },
5401 { "isStyleSheetLoadingSubresources", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isStyleSheetLoadingSubresources), (intptr_t) (1) } },
5402 { "clearMemoryCache", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_clearMemoryCache), (intptr_t) (0) } },
5403 { "pruneMemoryCacheToSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pruneMemoryCacheToSize), (intptr_t) (1) } },
5404 { "destroyDecodedDataForAllImages", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_destroyDecodedDataForAllImages), (intptr_t) (0) } },
5405 { "memoryCacheSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_memoryCacheSize), (intptr_t) (0) } },
5406 { "setOverrideCachePolicy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setOverrideCachePolicy), (intptr_t) (1) } },
5407 { "setOverrideResourceLoadPriority", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setOverrideResourceLoadPriority), (intptr_t) (1) } },
5408 { "setStrictRawResourceValidationPolicyDisabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setStrictRawResourceValidationPolicyDisabled), (intptr_t) (1) } },
5409 { "clearBackForwardCache", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_clearBackForwardCache), (intptr_t) (0) } },
5410 { "backForwardCacheSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_backForwardCacheSize), (intptr_t) (0) } },
5411 { "preventDocumentFromEnteringBackForwardCache", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_preventDocumentFromEnteringBackForwardCache), (intptr_t) (0) } },
5412 { "computedStyleIncludingVisitedInfo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_computedStyleIncludingVisitedInfo), (intptr_t) (1) } },
5413 { "ensureUserAgentShadowRoot", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_ensureUserAgentShadowRoot), (intptr_t) (1) } },
5414 { "shadowRoot", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_shadowRoot), (intptr_t) (1) } },
5415 { "deferredStyleRulesCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_deferredStyleRulesCount), (intptr_t) (1) } },
5416 { "deferredGroupRulesCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_deferredGroupRulesCount), (intptr_t) (1) } },
5417 { "deferredKeyframesRulesCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_deferredKeyframesRulesCount), (intptr_t) (1) } },
5418 { "shadowRootType", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_shadowRootType), (intptr_t) (1) } },
5419 { "shadowPseudoId", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_shadowPseudoId), (intptr_t) (1) } },
5420 { "setShadowPseudoId", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setShadowPseudoId), (intptr_t) (2) } },
5421 { "treeScopeRootNode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_treeScopeRootNode), (intptr_t) (1) } },
5422 { "parentTreeScope", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_parentTreeScope), (intptr_t) (1) } },
5423 { "lastSpatialNavigationCandidateCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_lastSpatialNavigationCandidateCount), (intptr_t) (0) } },
5424 { "animationWithIdExists", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_animationWithIdExists), (intptr_t) (1) } },
5425 { "numberOfActiveAnimations", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_numberOfActiveAnimations), (intptr_t) (0) } },
5426 { "suspendAnimations", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_suspendAnimations), (intptr_t) (0) } },
5427 { "resumeAnimations", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_resumeAnimations), (intptr_t) (0) } },
5428 { "animationsAreSuspended", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_animationsAreSuspended), (intptr_t) (0) } },
5429 { "acceleratedAnimationsForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_acceleratedAnimationsForElement), (intptr_t) (1) } },
5430 { "numberOfAnimationTimelineInvalidations", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_numberOfAnimationTimelineInvalidations), (intptr_t) (0) } },
5431 { "timeToNextAnimationTick", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_timeToNextAnimationTick), (intptr_t) (1) } },
5432 { "pseudoElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pseudoElement), (intptr_t) (2) } },
5433 { "visiblePlaceholder", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_visiblePlaceholder), (intptr_t) (1) } },
5434 { "selectColorInColorChooser", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_selectColorInColorChooser), (intptr_t) (2) } },
5435 { "formControlStateOfPreviousHistoryItem", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_formControlStateOfPreviousHistoryItem), (intptr_t) (0) } },
5436 { "setFormControlStateOfPreviousHistoryItem", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setFormControlStateOfPreviousHistoryItem), (intptr_t) (1) } },
5437 { "absoluteLineRectFromPoint", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_absoluteLineRectFromPoint), (intptr_t) (2) } },
5438 { "absoluteCaretBounds", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_absoluteCaretBounds), (intptr_t) (0) } },
5439 { "isCaretBlinkingSuspended", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isCaretBlinkingSuspended), (intptr_t) (0) } },
5440 { "boundingBox", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_boundingBox), (intptr_t) (1) } },
5441 { "inspectorGridOverlayCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_inspectorGridOverlayCount), (intptr_t) (0) } },
5442 { "inspectorHighlightRects", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_inspectorHighlightRects), (intptr_t) (0) } },
5443 { "markerCountForNode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_markerCountForNode), (intptr_t) (2) } },
5444 { "markerRangeForNode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_markerRangeForNode), (intptr_t) (3) } },
5445 { "markerDescriptionForNode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_markerDescriptionForNode), (intptr_t) (3) } },
5446 { "dumpMarkerRects", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_dumpMarkerRects), (intptr_t) (1) } },
5447 { "setMarkedTextMatchesAreHighlighted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMarkedTextMatchesAreHighlighted), (intptr_t) (1) } },
5448 { "invalidateFontCache", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_invalidateFontCache), (intptr_t) (0) } },
5449 { "setFontSmoothingEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setFontSmoothingEnabled), (intptr_t) (1) } },
5450 { "setScrollViewPosition", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setScrollViewPosition), (intptr_t) (2) } },
5451 { "unconstrainedScrollTo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_unconstrainedScrollTo), (intptr_t) (3) } },
5452 { "scrollBySimulatingWheelEvent", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_scrollBySimulatingWheelEvent), (intptr_t) (3) } },
5453 { "layoutViewportRect", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_layoutViewportRect), (intptr_t) (0) } },
5454 { "visualViewportRect", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_visualViewportRect), (intptr_t) (0) } },
5455 { "setViewIsTransparent", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setViewIsTransparent), (intptr_t) (1) } },
5456 { "viewBaseBackgroundColor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_viewBaseBackgroundColor), (intptr_t) (0) } },
5457 { "setViewBaseBackgroundColor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setViewBaseBackgroundColor), (intptr_t) (1) } },
5458 { "setPagination", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setPagination), (intptr_t) (2) } },
5459 { "setPaginationLineGridEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setPaginationLineGridEnabled), (intptr_t) (1) } },
5460 { "configurationForViewport", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_configurationForViewport), (intptr_t) (5) } },
5461 { "wasLastChangeUserEdit", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_wasLastChangeUserEdit), (intptr_t) (1) } },
5462 { "elementShouldAutoComplete", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_elementShouldAutoComplete), (intptr_t) (1) } },
5463 { "setAutofilled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setAutofilled), (intptr_t) (2) } },
5464 { "setAutoFilledAndViewable", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setAutoFilledAndViewable), (intptr_t) (2) } },
5465 { "setShowAutoFillButton", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setShowAutoFillButton), (intptr_t) (2) } },
5466 { "autoFillButtonType", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_autoFillButtonType), (intptr_t) (1) } },
5467 { "lastAutoFillButtonType", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_lastAutoFillButtonType), (intptr_t) (1) } },
5468 { "setCanShowPlaceholder", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setCanShowPlaceholder), (intptr_t) (2) } },
5469 { "insertTextPlaceholder", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_insertTextPlaceholder), (intptr_t) (2) } },
5470 { "removeTextPlaceholder", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_removeTextPlaceholder), (intptr_t) (1) } },
5471 { "rangeOfString", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_rangeOfString), (intptr_t) (3) } },
5472 { "countMatchesForText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_countMatchesForText), (intptr_t) (3) } },
5473 { "countFindMatches", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_countFindMatches), (intptr_t) (2) } },
5474 { "autofillFieldName", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_autofillFieldName), (intptr_t) (1) } },
5475 { "isSpellcheckDisabledExceptTextReplacement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isSpellcheckDisabledExceptTextReplacement), (intptr_t) (1) } },
5476 { "invalidateControlTints", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_invalidateControlTints), (intptr_t) (0) } },
5477 { "scrollElementToRect", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_scrollElementToRect), (intptr_t) (5) } },
5478 { "rangeFromLocationAndLength", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_rangeFromLocationAndLength), (intptr_t) (3) } },
5479 { "locationFromRange", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_locationFromRange), (intptr_t) (2) } },
5480 { "lengthFromRange", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_lengthFromRange), (intptr_t) (2) } },
5481 { "rangeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_rangeAsText), (intptr_t) (1) } },
5482 { "rangeAsTextUsingBackwardsTextIterator", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_rangeAsTextUsingBackwardsTextIterator), (intptr_t) (1) } },
5483 { "subrange", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_subrange), (intptr_t) (3) } },
5484 { "rangeForDictionaryLookupAtLocation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_rangeForDictionaryLookupAtLocation), (intptr_t) (2) } },
5485 { "rangeOfStringNearLocation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_rangeOfStringNearLocation), (intptr_t) (3) } },
5486 { "setDelegatesScrolling", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setDelegatesScrolling), (intptr_t) (1) } },
5487 { "lastSpellCheckRequestSequence", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_lastSpellCheckRequestSequence), (intptr_t) (0) } },
5488 { "lastSpellCheckProcessedSequence", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_lastSpellCheckProcessedSequence), (intptr_t) (0) } },
5489 { "advanceToNextMisspelling", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_advanceToNextMisspelling), (intptr_t) (0) } },
5490 { "userPreferredLanguages", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_userPreferredLanguages), (intptr_t) (0) } },
5491 { "setUserPreferredLanguages", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setUserPreferredLanguages), (intptr_t) (1) } },
5492 { "userPreferredAudioCharacteristics", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_userPreferredAudioCharacteristics), (intptr_t) (0) } },
5493 { "setUserPreferredAudioCharacteristic", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setUserPreferredAudioCharacteristic), (intptr_t) (1) } },
5494 { "wheelEventHandlerCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_wheelEventHandlerCount), (intptr_t) (0) } },
5495 { "touchEventHandlerCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_touchEventHandlerCount), (intptr_t) (0) } },
5496 { "touchEventRectsForEvent", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_touchEventRectsForEvent), (intptr_t) (1) } },
5497 { "passiveTouchEventListenerRects", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_passiveTouchEventListenerRects), (intptr_t) (0) } },
5498 { "nodesFromRect", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_nodesFromRect), (intptr_t) (10) } },
5499 { "parserMetaData", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_parserMetaData), (intptr_t) (0) } },
5500 { "updateEditorUINowIfScheduled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_updateEditorUINowIfScheduled), (intptr_t) (0) } },
5501 { "hasSpellingMarker", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_hasSpellingMarker), (intptr_t) (2) } },
5502 { "hasGrammarMarker", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_hasGrammarMarker), (intptr_t) (2) } },
5503 { "hasAutocorrectedMarker", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_hasAutocorrectedMarker), (intptr_t) (2) } },
5504 { "hasDictationAlternativesMarker", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_hasDictationAlternativesMarker), (intptr_t) (2) } },
5505 { "setContinuousSpellCheckingEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setContinuousSpellCheckingEnabled), (intptr_t) (1) } },
5506 { "setAutomaticQuoteSubstitutionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setAutomaticQuoteSubstitutionEnabled), (intptr_t) (1) } },
5507 { "setAutomaticLinkDetectionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setAutomaticLinkDetectionEnabled), (intptr_t) (1) } },
5508 { "setAutomaticDashSubstitutionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setAutomaticDashSubstitutionEnabled), (intptr_t) (1) } },
5509 { "setAutomaticTextReplacementEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setAutomaticTextReplacementEnabled), (intptr_t) (1) } },
5510 { "setAutomaticSpellingCorrectionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setAutomaticSpellingCorrectionEnabled), (intptr_t) (1) } },
5511 { "handleAcceptedCandidate", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_handleAcceptedCandidate), (intptr_t) (3) } },
5512 { "changeSelectionListType", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_changeSelectionListType), (intptr_t) (0) } },
5513 { "changeBackToReplacedString", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_changeBackToReplacedString), (intptr_t) (1) } },
5514 { "isOverwriteModeEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isOverwriteModeEnabled), (intptr_t) (0) } },
5515 { "toggleOverwriteModeEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_toggleOverwriteModeEnabled), (intptr_t) (0) } },
5516 { "numberOfScrollableAreas", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_numberOfScrollableAreas), (intptr_t) (0) } },
5517 { "isPageBoxVisible", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isPageBoxVisible), (intptr_t) (1) } },
5518 { "imageFrameIndex", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_imageFrameIndex), (intptr_t) (1) } },
5519 { "imageFrameCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_imageFrameCount), (intptr_t) (1) } },
5520 { "imageFrameDurationAtIndex", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_imageFrameDurationAtIndex), (intptr_t) (2) } },
5521 { "setImageFrameDecodingDuration", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setImageFrameDecodingDuration), (intptr_t) (2) } },
5522 { "resetImageAnimation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_resetImageAnimation), (intptr_t) (1) } },
5523 { "isImageAnimating", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isImageAnimating), (intptr_t) (1) } },
5524 { "imagePendingDecodePromisesCountForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_imagePendingDecodePromisesCountForTesting), (intptr_t) (1) } },
5525 { "setClearDecoderAfterAsyncFrameRequestForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setClearDecoderAfterAsyncFrameRequestForTesting), (intptr_t) (2) } },
5526 { "imageDecodeCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_imageDecodeCount), (intptr_t) (1) } },
5527 { "pdfDocumentCachingCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pdfDocumentCachingCount), (intptr_t) (1) } },
5528 { "setLargeImageAsyncDecodingEnabledForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setLargeImageAsyncDecodingEnabledForTesting), (intptr_t) (2) } },
5529 { "setForceUpdateImageDataEnabledForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setForceUpdateImageDataEnabledForTesting), (intptr_t) (2) } },
5530 { "setGridMaxTracksLimit", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setGridMaxTracksLimit), (intptr_t) (1) } },
5531 { "svgAnimationsInterval", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_svgAnimationsInterval), (intptr_t) (1) } },
5532 { "testProcessIncomingSyncMessagesWhenWaitingForSyncReply", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_testProcessIncomingSyncMessagesWhenWaitingForSyncReply), (intptr_t) (0) } },
5533 { "layerTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_layerTreeAsText), (intptr_t) (1) } },
5534 { "layerIDForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_layerIDForElement), (intptr_t) (1) } },
5535 { "platformLayerTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_platformLayerTreeAsText), (intptr_t) (1) } },
5536 { "scrollbarOverlayStyle", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_scrollbarOverlayStyle), (intptr_t) (0) } },
5537 { "scrollbarUsingDarkAppearance", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_scrollbarUsingDarkAppearance), (intptr_t) (0) } },
5538 { "horizontalScrollbarState", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_horizontalScrollbarState), (intptr_t) (0) } },
5539 { "verticalScrollbarState", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_verticalScrollbarState), (intptr_t) (0) } },
5540 { "scrollingStateTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_scrollingStateTreeAsText), (intptr_t) (0) } },
5541 { "scrollingTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_scrollingTreeAsText), (intptr_t) (0) } },
5542 { "synchronousScrollingReasons", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_synchronousScrollingReasons), (intptr_t) (0) } },
5543 { "nonFastScrollableRects", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_nonFastScrollableRects), (intptr_t) (0) } },
5544 { "repaintRectsAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_repaintRectsAsText), (intptr_t) (0) } },
5545 { "setElementUsesDisplayListDrawing", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setElementUsesDisplayListDrawing), (intptr_t) (2) } },
5546 { "setElementTracksDisplayListReplay", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setElementTracksDisplayListReplay), (intptr_t) (2) } },
5547 { "displayListForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_displayListForElement), (intptr_t) (1) } },
5548 { "replayDisplayListForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_replayDisplayListForElement), (intptr_t) (1) } },
5549 { "garbageCollectDocumentResources", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_garbageCollectDocumentResources), (intptr_t) (0) } },
5550 { "insertAuthorCSS", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_insertAuthorCSS), (intptr_t) (1) } },
5551 { "insertUserCSS", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_insertUserCSS), (intptr_t) (1) } },
5552 { "beginSimulatedMemoryPressure", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_beginSimulatedMemoryPressure), (intptr_t) (0) } },
5553 { "endSimulatedMemoryPressure", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_endSimulatedMemoryPressure), (intptr_t) (0) } },
5554 { "numberOfIDBTransactions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_numberOfIDBTransactions), (intptr_t) (0) } },
5555 { "numberOfLiveNodes", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_numberOfLiveNodes), (intptr_t) (0) } },
5556 { "numberOfLiveDocuments", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_numberOfLiveDocuments), (intptr_t) (0) } },
5557 { "referencingNodeCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_referencingNodeCount), (intptr_t) (1) } },
5558#if ENABLE(INTERSECTION_OBSERVER)
5559 { "numberOfIntersectionObservers", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_numberOfIntersectionObservers), (intptr_t) (1) } },
5560#else
5561 { 0, 0, NoIntrinsic, { 0, 0 } },
5562#endif
5563#if ENABLE(RESIZE_OBSERVER)
5564 { "numberOfResizeObservers", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_numberOfResizeObservers), (intptr_t) (1) } },
5565#else
5566 { 0, 0, NoIntrinsic, { 0, 0 } },
5567#endif
5568 { "openDummyInspectorFrontend", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_openDummyInspectorFrontend), (intptr_t) (1) } },
5569 { "closeDummyInspectorFrontend", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_closeDummyInspectorFrontend), (intptr_t) (0) } },
5570 { "setInspectorIsUnderTest", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setInspectorIsUnderTest), (intptr_t) (1) } },
5571#if ENABLE(WEB_AUDIO)
5572 { "baseAudioContextIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_baseAudioContextIdentifier), (intptr_t) (1) } },
5573#else
5574 { 0, 0, NoIntrinsic, { 0, 0 } },
5575#endif
5576#if ENABLE(WEB_AUDIO)
5577 { "isBaseAudioContextAlive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isBaseAudioContextAlive), (intptr_t) (1) } },
5578#else
5579 { 0, 0, NoIntrinsic, { 0, 0 } },
5580#endif
5581 { "counterValue", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_counterValue), (intptr_t) (1) } },
5582 { "pageNumber", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pageNumber), (intptr_t) (1) } },
5583 { "shortcutIconURLs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_shortcutIconURLs), (intptr_t) (0) } },
5584 { "numberOfPages", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_numberOfPages), (intptr_t) (0) } },
5585 { "pageProperty", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pageProperty), (intptr_t) (2) } },
5586 { "pageSizeAndMarginsInPixels", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pageSizeAndMarginsInPixels), (intptr_t) (7) } },
5587 { "setPageScaleFactor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setPageScaleFactor), (intptr_t) (3) } },
5588 { "pageScaleFactor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pageScaleFactor), (intptr_t) (0) } },
5589 { "setPageZoomFactor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setPageZoomFactor), (intptr_t) (1) } },
5590 { "setTextZoomFactor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setTextZoomFactor), (intptr_t) (1) } },
5591 { "setUseFixedLayout", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setUseFixedLayout), (intptr_t) (1) } },
5592 { "setFixedLayoutSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setFixedLayoutSize), (intptr_t) (2) } },
5593 { "setPrinting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setPrinting), (intptr_t) (2) } },
5594 { "setViewExposedRect", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setViewExposedRect), (intptr_t) (4) } },
5595 { "setHeaderHeight", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setHeaderHeight), (intptr_t) (1) } },
5596 { "setFooterHeight", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setFooterHeight), (intptr_t) (1) } },
5597 { "setTopContentInset", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setTopContentInset), (intptr_t) (1) } },
5598#if ENABLE(FULLSCREEN_API)
5599 { "webkitWillEnterFullScreenForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_webkitWillEnterFullScreenForElement), (intptr_t) (1) } },
5600#else
5601 { 0, 0, NoIntrinsic, { 0, 0 } },
5602#endif
5603#if ENABLE(FULLSCREEN_API)
5604 { "webkitDidEnterFullScreenForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_webkitDidEnterFullScreenForElement), (intptr_t) (1) } },
5605#else
5606 { 0, 0, NoIntrinsic, { 0, 0 } },
5607#endif
5608#if ENABLE(FULLSCREEN_API)
5609 { "webkitWillExitFullScreenForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_webkitWillExitFullScreenForElement), (intptr_t) (1) } },
5610#else
5611 { 0, 0, NoIntrinsic, { 0, 0 } },
5612#endif
5613#if ENABLE(FULLSCREEN_API)
5614 { "webkitDidExitFullScreenForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_webkitDidExitFullScreenForElement), (intptr_t) (1) } },
5615#else
5616 { 0, 0, NoIntrinsic, { 0, 0 } },
5617#endif
5618 { "setFullscreenInsets", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setFullscreenInsets), (intptr_t) (1) } },
5619 { "setFullscreenAutoHideDuration", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setFullscreenAutoHideDuration), (intptr_t) (1) } },
5620 { "setFullscreenControlsHidden", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setFullscreenControlsHidden), (intptr_t) (1) } },
5621#if ENABLE(VIDEO)
5622 { "isChangingPresentationMode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isChangingPresentationMode), (intptr_t) (1) } },
5623#else
5624 { 0, 0, NoIntrinsic, { 0, 0 } },
5625#endif
5626#if ENABLE(VIDEO_PRESENTATION_MODE)
5627 { "setMockVideoPresentationModeEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMockVideoPresentationModeEnabled), (intptr_t) (1) } },
5628#else
5629 { 0, 0, NoIntrinsic, { 0, 0 } },
5630#endif
5631 { "setApplicationCacheOriginQuota", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setApplicationCacheOriginQuota), (intptr_t) (1) } },
5632 { "registerURLSchemeAsBypassingContentSecurityPolicy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_registerURLSchemeAsBypassingContentSecurityPolicy), (intptr_t) (1) } },
5633 { "removeURLSchemeRegisteredAsBypassingContentSecurityPolicy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_removeURLSchemeRegisteredAsBypassingContentSecurityPolicy), (intptr_t) (1) } },
5634 { "registerDefaultPortForProtocol", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_registerDefaultPortForProtocol), (intptr_t) (2) } },
5635 { "mallocStatistics", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_mallocStatistics), (intptr_t) (0) } },
5636 { "typeConversions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_typeConversions), (intptr_t) (0) } },
5637 { "memoryInfo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_memoryInfo), (intptr_t) (0) } },
5638 { "getReferencedFilePaths", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_getReferencedFilePaths), (intptr_t) (0) } },
5639 { "startTrackingRepaints", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_startTrackingRepaints), (intptr_t) (0) } },
5640 { "stopTrackingRepaints", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_stopTrackingRepaints), (intptr_t) (0) } },
5641 { "startTrackingLayerFlushes", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_startTrackingLayerFlushes), (intptr_t) (0) } },
5642 { "layerFlushCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_layerFlushCount), (intptr_t) (0) } },
5643 { "isTimerThrottled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isTimerThrottled), (intptr_t) (1) } },
5644 { "requestAnimationFrameThrottlingReasons", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_requestAnimationFrameThrottlingReasons), (intptr_t) (0) } },
5645 { "areTimersThrottled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_areTimersThrottled), (intptr_t) (0) } },
5646 { "setLowPowerModeEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setLowPowerModeEnabled), (intptr_t) (1) } },
5647 { "setOutsideViewportThrottlingEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setOutsideViewportThrottlingEnabled), (intptr_t) (1) } },
5648 { "startTrackingStyleRecalcs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_startTrackingStyleRecalcs), (intptr_t) (0) } },
5649 { "styleRecalcCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_styleRecalcCount), (intptr_t) (0) } },
5650 { "startTrackingCompositingUpdates", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_startTrackingCompositingUpdates), (intptr_t) (0) } },
5651 { "compositingUpdateCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_compositingUpdateCount), (intptr_t) (0) } },
5652 { "startTrackingRenderingUpdates", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_startTrackingRenderingUpdates), (intptr_t) (0) } },
5653 { "renderingUpdateCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_renderingUpdateCount), (intptr_t) (0) } },
5654 { "updateLayoutAndStyleForAllFrames", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_updateLayoutAndStyleForAllFrames), (intptr_t) (0) } },
5655 { "updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks), (intptr_t) (0) } },
5656 { "getCurrentCursorInfo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_getCurrentCursorInfo), (intptr_t) (0) } },
5657 { "markerTextForListItem", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_markerTextForListItem), (intptr_t) (1) } },
5658 { "toolTipFromElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_toolTipFromElement), (intptr_t) (1) } },
5659 { "deserializeBuffer", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_deserializeBuffer), (intptr_t) (1) } },
5660 { "serializeObject", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_serializeObject), (intptr_t) (1) } },
5661 { "isFromCurrentWorld", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isFromCurrentWorld), (intptr_t) (1) } },
5662 { "evaluateInWorldIgnoringException", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_evaluateInWorldIgnoringException), (intptr_t) (2) } },
5663 { "setUsesOverlayScrollbars", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setUsesOverlayScrollbars), (intptr_t) (1) } },
5664 { "setUsesMockScrollAnimator", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setUsesMockScrollAnimator), (intptr_t) (1) } },
5665 { "forceReload", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_forceReload), (intptr_t) (1) } },
5666 { "reloadExpiredOnly", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_reloadExpiredOnly), (intptr_t) (0) } },
5667 { "enableFixedWidthAutoSizeMode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_enableFixedWidthAutoSizeMode), (intptr_t) (3) } },
5668 { "enableSizeToContentAutoSizeMode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_enableSizeToContentAutoSizeMode), (intptr_t) (3) } },
5669#if ENABLE(VIDEO)
5670 { "mediaResponseSources", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_mediaResponseSources), (intptr_t) (1) } },
5671#else
5672 { 0, 0, NoIntrinsic, { 0, 0 } },
5673#endif
5674#if ENABLE(VIDEO)
5675 { "mediaResponseContentRanges", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_mediaResponseContentRanges), (intptr_t) (1) } },
5676#else
5677 { 0, 0, NoIntrinsic, { 0, 0 } },
5678#endif
5679#if ENABLE(VIDEO)
5680 { "simulateAudioInterruption", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_simulateAudioInterruption), (intptr_t) (1) } },
5681#else
5682 { 0, 0, NoIntrinsic, { 0, 0 } },
5683#endif
5684#if ENABLE(VIDEO)
5685 { "mediaElementHasCharacteristic", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_mediaElementHasCharacteristic), (intptr_t) (2) } },
5686#else
5687 { 0, 0, NoIntrinsic, { 0, 0 } },
5688#endif
5689#if ENABLE(VIDEO)
5690 { "beginSimulatedHDCPError", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_beginSimulatedHDCPError), (intptr_t) (1) } },
5691#else
5692 { 0, 0, NoIntrinsic, { 0, 0 } },
5693#endif
5694#if ENABLE(VIDEO)
5695 { "endSimulatedHDCPError", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_endSimulatedHDCPError), (intptr_t) (1) } },
5696#else
5697 { 0, 0, NoIntrinsic, { 0, 0 } },
5698#endif
5699#if ENABLE(VIDEO)
5700 { "elementShouldBufferData", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_elementShouldBufferData), (intptr_t) (1) } },
5701#else
5702 { 0, 0, NoIntrinsic, { 0, 0 } },
5703#endif
5704#if ENABLE(VIDEO)
5705 { "elementBufferingPolicy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_elementBufferingPolicy), (intptr_t) (1) } },
5706#else
5707 { 0, 0, NoIntrinsic, { 0, 0 } },
5708#endif
5709#if ENABLE(VIDEO)
5710 { "privatePlayerVolume", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_privatePlayerVolume), (intptr_t) (1) } },
5711#else
5712 { 0, 0, NoIntrinsic, { 0, 0 } },
5713#endif
5714#if ENABLE(VIDEO)
5715 { "privatePlayerMuted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_privatePlayerMuted), (intptr_t) (1) } },
5716#else
5717 { 0, 0, NoIntrinsic, { 0, 0 } },
5718#endif
5719#if ENABLE(VIDEO)
5720 { "isMediaElementHidden", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isMediaElementHidden), (intptr_t) (1) } },
5721#else
5722 { 0, 0, NoIntrinsic, { 0, 0 } },
5723#endif
5724#if ENABLE(VIDEO)
5725 { "setOverridePreferredDynamicRangeMode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setOverridePreferredDynamicRangeMode), (intptr_t) (2) } },
5726#else
5727 { 0, 0, NoIntrinsic, { 0, 0 } },
5728#endif
5729 { "setIsPlayingToBluetoothOverride", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setIsPlayingToBluetoothOverride), (intptr_t) (0) } },
5730#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
5731 { "initializeMockCDM", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_initializeMockCDM), (intptr_t) (0) } },
5732#else
5733 { 0, 0, NoIntrinsic, { 0, 0 } },
5734#endif
5735#if ENABLE(ENCRYPTED_MEDIA)
5736 { "registerMockCDM", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_registerMockCDM), (intptr_t) (0) } },
5737#else
5738 { 0, 0, NoIntrinsic, { 0, 0 } },
5739#endif
5740 { "enableMockMediaCapabilities", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_enableMockMediaCapabilities), (intptr_t) (0) } },
5741#if ENABLE(SPEECH_SYNTHESIS)
5742 { "enableMockSpeechSynthesizer", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_enableMockSpeechSynthesizer), (intptr_t) (0) } },
5743#else
5744 { 0, 0, NoIntrinsic, { 0, 0 } },
5745#endif
5746 { "getImageSourceURL", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_getImageSourceURL), (intptr_t) (1) } },
5747#if ENABLE(VIDEO)
5748 { "captionsStyleSheetOverride", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_captionsStyleSheetOverride), (intptr_t) (0) } },
5749#else
5750 { 0, 0, NoIntrinsic, { 0, 0 } },
5751#endif
5752#if ENABLE(VIDEO)
5753 { "setCaptionsStyleSheetOverride", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setCaptionsStyleSheetOverride), (intptr_t) (1) } },
5754#else
5755 { 0, 0, NoIntrinsic, { 0, 0 } },
5756#endif
5757#if ENABLE(VIDEO)
5758 { "setPrimaryAudioTrackLanguageOverride", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setPrimaryAudioTrackLanguageOverride), (intptr_t) (1) } },
5759#else
5760 { 0, 0, NoIntrinsic, { 0, 0 } },
5761#endif
5762#if ENABLE(VIDEO)
5763 { "setCaptionDisplayMode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setCaptionDisplayMode), (intptr_t) (1) } },
5764#else
5765 { 0, 0, NoIntrinsic, { 0, 0 } },
5766#endif
5767#if ENABLE(VIDEO)
5768 { "createGenericCue", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_createGenericCue), (intptr_t) (3) } },
5769#else
5770 { 0, 0, NoIntrinsic, { 0, 0 } },
5771#endif
5772#if ENABLE(VIDEO)
5773 { "textTrackBCP47Language", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_textTrackBCP47Language), (intptr_t) (1) } },
5774#else
5775 { 0, 0, NoIntrinsic, { 0, 0 } },
5776#endif
5777#if ENABLE(VIDEO)
5778 { "createTimeRanges", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_createTimeRanges), (intptr_t) (2) } },
5779#else
5780 { 0, 0, NoIntrinsic, { 0, 0 } },
5781#endif
5782#if ENABLE(VIDEO)
5783 { "closestTimeToTimeRanges", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_closestTimeToTimeRanges), (intptr_t) (2) } },
5784#else
5785 { 0, 0, NoIntrinsic, { 0, 0 } },
5786#endif
5787 { "isSelectPopupVisible", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isSelectPopupVisible), (intptr_t) (1) } },
5788 { "isPluginUnavailabilityIndicatorObscured", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isPluginUnavailabilityIndicatorObscured), (intptr_t) (1) } },
5789 { "unavailablePluginReplacementText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_unavailablePluginReplacementText), (intptr_t) (1) } },
5790 { "isPluginSnapshotted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isPluginSnapshotted), (intptr_t) (1) } },
5791 { "pluginIsBelowSizeThreshold", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pluginIsBelowSizeThreshold), (intptr_t) (1) } },
5792 { "selectionBounds", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_selectionBounds), (intptr_t) (0) } },
5793 { "setSelectionWithoutValidation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setSelectionWithoutValidation), (intptr_t) (4) } },
5794#if ENABLE(MEDIA_SOURCE)
5795 { "initializeMockMediaSource", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_initializeMockMediaSource), (intptr_t) (0) } },
5796#else
5797 { 0, 0, NoIntrinsic, { 0, 0 } },
5798#endif
5799#if ENABLE(MEDIA_SOURCE)
5800 { "bufferedSamplesForTrackId", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_bufferedSamplesForTrackId), (intptr_t) (2) } },
5801#else
5802 { 0, 0, NoIntrinsic, { 0, 0 } },
5803#endif
5804#if ENABLE(MEDIA_SOURCE)
5805 { "enqueuedSamplesForTrackID", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_enqueuedSamplesForTrackID), (intptr_t) (2) } },
5806#else
5807 { 0, 0, NoIntrinsic, { 0, 0 } },
5808#endif
5809#if ENABLE(MEDIA_SOURCE)
5810 { "setShouldGenerateTimestamps", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setShouldGenerateTimestamps), (intptr_t) (2) } },
5811#else
5812 { 0, 0, NoIntrinsic, { 0, 0 } },
5813#endif
5814#if ENABLE(MEDIA_SOURCE)
5815 { "minimumUpcomingPresentationTimeForTrackID", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_minimumUpcomingPresentationTimeForTrackID), (intptr_t) (2) } },
5816#else
5817 { 0, 0, NoIntrinsic, { 0, 0 } },
5818#endif
5819#if ENABLE(MEDIA_SOURCE)
5820 { "setMaximumQueueDepthForTrackID", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMaximumQueueDepthForTrackID), (intptr_t) (3) } },
5821#else
5822 { 0, 0, NoIntrinsic, { 0, 0 } },
5823#endif
5824#if ENABLE(VIDEO)
5825 { "beginMediaSessionInterruption", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_beginMediaSessionInterruption), (intptr_t) (1) } },
5826#else
5827 { 0, 0, NoIntrinsic, { 0, 0 } },
5828#endif
5829#if ENABLE(VIDEO)
5830 { "endMediaSessionInterruption", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_endMediaSessionInterruption), (intptr_t) (1) } },
5831#else
5832 { 0, 0, NoIntrinsic, { 0, 0 } },
5833#endif
5834#if ENABLE(VIDEO)
5835 { "applicationWillBecomeInactive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_applicationWillBecomeInactive), (intptr_t) (0) } },
5836#else
5837 { 0, 0, NoIntrinsic, { 0, 0 } },
5838#endif
5839#if ENABLE(VIDEO)
5840 { "applicationDidBecomeActive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_applicationDidBecomeActive), (intptr_t) (0) } },
5841#else
5842 { 0, 0, NoIntrinsic, { 0, 0 } },
5843#endif
5844#if ENABLE(VIDEO)
5845 { "applicationWillEnterForeground", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_applicationWillEnterForeground), (intptr_t) (0) } },
5846#else
5847 { 0, 0, NoIntrinsic, { 0, 0 } },
5848#endif
5849#if ENABLE(VIDEO)
5850 { "applicationDidEnterBackground", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_applicationDidEnterBackground), (intptr_t) (0) } },
5851#else
5852 { 0, 0, NoIntrinsic, { 0, 0 } },
5853#endif
5854#if ENABLE(VIDEO)
5855 { "setMediaSessionRestrictions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMediaSessionRestrictions), (intptr_t) (2) } },
5856#else
5857 { 0, 0, NoIntrinsic, { 0, 0 } },
5858#endif
5859#if ENABLE(VIDEO)
5860 { "mediaSessionRestrictions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_mediaSessionRestrictions), (intptr_t) (1) } },
5861#else
5862 { 0, 0, NoIntrinsic, { 0, 0 } },
5863#endif
5864#if ENABLE(VIDEO)
5865 { "setMediaElementRestrictions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMediaElementRestrictions), (intptr_t) (2) } },
5866#else
5867 { 0, 0, NoIntrinsic, { 0, 0 } },
5868#endif
5869#if ENABLE(WEB_AUDIO)
5870 { "setAudioContextRestrictions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setAudioContextRestrictions), (intptr_t) (2) } },
5871#else
5872 { 0, 0, NoIntrinsic, { 0, 0 } },
5873#endif
5874#if ENABLE(VIDEO)
5875 { "postRemoteControlCommand", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_postRemoteControlCommand), (intptr_t) (1) } },
5876#else
5877 { 0, 0, NoIntrinsic, { 0, 0 } },
5878#endif
5879#if ENABLE(VIDEO)
5880 { "activeAudioRouteDidChange", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_activeAudioRouteDidChange), (intptr_t) (1) } },
5881#else
5882 { 0, 0, NoIntrinsic, { 0, 0 } },
5883#endif
5884#if ENABLE(WIRELESS_PLAYBACK_TARGET)
5885 { "setMockMediaPlaybackTargetPickerEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMockMediaPlaybackTargetPickerEnabled), (intptr_t) (1) } },
5886#else
5887 { 0, 0, NoIntrinsic, { 0, 0 } },
5888#endif
5889#if ENABLE(WIRELESS_PLAYBACK_TARGET)
5890 { "setMockMediaPlaybackTargetPickerState", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMockMediaPlaybackTargetPickerState), (intptr_t) (2) } },
5891#else
5892 { 0, 0, NoIntrinsic, { 0, 0 } },
5893#endif
5894#if ENABLE(WIRELESS_PLAYBACK_TARGET)
5895 { "mockMediaPlaybackTargetPickerDismissPopup", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_mockMediaPlaybackTargetPickerDismissPopup), (intptr_t) (0) } },
5896#else
5897 { 0, 0, NoIntrinsic, { 0, 0 } },
5898#endif
5899#if ENABLE(MEDIA_STREAM)
5900 { "setCustomPrivateRecorderCreator", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setCustomPrivateRecorderCreator), (intptr_t) (0) } },
5901#else
5902 { 0, 0, NoIntrinsic, { 0, 0 } },
5903#endif
5904#if ENABLE(WEB_AUDIO)
5905 { "useMockAudioDestinationCocoa", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_useMockAudioDestinationCocoa), (intptr_t) (0) } },
5906#else
5907 { 0, 0, NoIntrinsic, { 0, 0 } },
5908#endif
5909#if ENABLE(WEB_RTC)
5910 { "emulateRTCPeerConnectionPlatformEvent", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_emulateRTCPeerConnectionPlatformEvent), (intptr_t) (2) } },
5911#else
5912 { 0, 0, NoIntrinsic, { 0, 0 } },
5913#endif
5914#if ENABLE(WEB_RTC)
5915 { "useMockRTCPeerConnectionFactory", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_useMockRTCPeerConnectionFactory), (intptr_t) (1) } },
5916#else
5917 { 0, 0, NoIntrinsic, { 0, 0 } },
5918#endif
5919#if ENABLE(WEB_RTC)
5920 { "setICECandidateFiltering", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setICECandidateFiltering), (intptr_t) (1) } },
5921#else
5922 { 0, 0, NoIntrinsic, { 0, 0 } },
5923#endif
5924#if ENABLE(WEB_RTC)
5925 { "setEnumeratingAllNetworkInterfacesEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setEnumeratingAllNetworkInterfacesEnabled), (intptr_t) (1) } },
5926#else
5927 { 0, 0, NoIntrinsic, { 0, 0 } },
5928#endif
5929#if ENABLE(WEB_RTC)
5930 { "stopPeerConnection", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_stopPeerConnection), (intptr_t) (1) } },
5931#else
5932 { 0, 0, NoIntrinsic, { 0, 0 } },
5933#endif
5934#if ENABLE(WEB_RTC)
5935 { "clearPeerConnectionFactory", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_clearPeerConnectionFactory), (intptr_t) (0) } },
5936#else
5937 { 0, 0, NoIntrinsic, { 0, 0 } },
5938#endif
5939#if ENABLE(WEB_RTC)
5940 { "setEnableWebRTCEncryption", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setEnableWebRTCEncryption), (intptr_t) (1) } },
5941#else
5942 { 0, 0, NoIntrinsic, { 0, 0 } },
5943#endif
5944#if ENABLE(WEB_RTC)
5945 { "setUseDTLS10", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setUseDTLS10), (intptr_t) (1) } },
5946#else
5947 { 0, 0, NoIntrinsic, { 0, 0 } },
5948#endif
5949#if ENABLE(VIDEO)
5950 { "simulateSystemSleep", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_simulateSystemSleep), (intptr_t) (0) } },
5951#else
5952 { 0, 0, NoIntrinsic, { 0, 0 } },
5953#endif
5954#if ENABLE(VIDEO)
5955 { "simulateSystemWake", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_simulateSystemWake), (intptr_t) (0) } },
5956#else
5957 { 0, 0, NoIntrinsic, { 0, 0 } },
5958#endif
5959#if ENABLE(VIDEO)
5960 { "elementIsBlockingDisplaySleep", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_elementIsBlockingDisplaySleep), (intptr_t) (1) } },
5961#else
5962 { 0, 0, NoIntrinsic, { 0, 0 } },
5963#endif
5964 { "installMockPageOverlay", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_installMockPageOverlay), (intptr_t) (1) } },
5965 { "pageOverlayLayerTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pageOverlayLayerTreeAsText), (intptr_t) (0) } },
5966 { "setPageMuted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setPageMuted), (intptr_t) (1) } },
5967 { "pageMediaState", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pageMediaState), (intptr_t) (0) } },
5968 { "setPageDefersLoading", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setPageDefersLoading), (intptr_t) (1) } },
5969 { "pageDefersLoading", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pageDefersLoading), (intptr_t) (0) } },
5970 { "createFile", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_createFile), (intptr_t) (1) } },
5971 { "queueMicroTask", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_queueMicroTask), (intptr_t) (1) } },
5972 { "testPreloaderSettingViewport", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_testPreloaderSettingViewport), (intptr_t) (0) } },
5973 { "scrollSnapOffsets", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_scrollSnapOffsets), (intptr_t) (1) } },
5974 { "isScrollSnapInProgress", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isScrollSnapInProgress), (intptr_t) (1) } },
5975 { "setPlatformMomentumScrollingPredictionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setPlatformMomentumScrollingPredictionEnabled), (intptr_t) (1) } },
5976 { "pathStringWithShrinkWrappedRects", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pathStringWithShrinkWrappedRects), (intptr_t) (2) } },
5977#if ENABLE(VIDEO)
5978 { "getCurrentMediaControlsStatusForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_getCurrentMediaControlsStatusForElement), (intptr_t) (1) } },
5979#else
5980 { 0, 0, NoIntrinsic, { 0, 0 } },
5981#endif
5982#if ENABLE(VIDEO)
5983 { "setMediaControlsMaximumRightContainerButtonCountOverride", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMediaControlsMaximumRightContainerButtonCountOverride), (intptr_t) (2) } },
5984#else
5985 { 0, 0, NoIntrinsic, { 0, 0 } },
5986#endif
5987#if ENABLE(VIDEO)
5988 { "setMediaControlsHidePlaybackRates", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMediaControlsHidePlaybackRates), (intptr_t) (2) } },
5989#else
5990 { 0, 0, NoIntrinsic, { 0, 0 } },
5991#endif
5992 { "userVisibleString", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_userVisibleString), (intptr_t) (1) } },
5993 { "setPageMediaVolume", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setPageMediaVolume), (intptr_t) (1) } },
5994 { "setShowAllPlugins", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setShowAllPlugins), (intptr_t) (1) } },
5995 { "cloneArrayBuffer", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_cloneArrayBuffer), (intptr_t) (3) } },
5996 { "isReadableStreamDisturbed", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isReadableStreamDisturbed), (intptr_t) (1) } },
5997 { "resourceLoadStatisticsForURL", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_resourceLoadStatisticsForURL), (intptr_t) (1) } },
5998 { "setResourceLoadStatisticsEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setResourceLoadStatisticsEnabled), (intptr_t) (1) } },
5999 { "setCanShowModalDialogOverride", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setCanShowModalDialogOverride), (intptr_t) (1) } },
6000 { "composedTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_composedTreeAsText), (intptr_t) (1) } },
6001 { "isProcessingUserGesture", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isProcessingUserGesture), (intptr_t) (0) } },
6002 { "lastHandledUserGestureTimestamp", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_lastHandledUserGestureTimestamp), (intptr_t) (0) } },
6003 { "withUserGesture", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_withUserGesture), (intptr_t) (1) } },
6004 { "withoutUserGesture", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_withoutUserGesture), (intptr_t) (1) } },
6005 { "userIsInteracting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_userIsInteracting), (intptr_t) (0) } },
6006 { "observeGC", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_observeGC), (intptr_t) (1) } },
6007 { "setUserInterfaceLayoutDirection", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setUserInterfaceLayoutDirection), (intptr_t) (1) } },
6008 { "setBaseWritingDirection", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setBaseWritingDirection), (intptr_t) (1) } },
6009 { "userPrefersContrast", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_userPrefersContrast), (intptr_t) (0) } },
6010 { "userPrefersReducedMotion", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_userPrefersReducedMotion), (intptr_t) (0) } },
6011 { "reportBacktrace", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_reportBacktrace), (intptr_t) (0) } },
6012#if ENABLE(POINTER_LOCK)
6013 { "pageHasPendingPointerLock", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pageHasPendingPointerLock), (intptr_t) (0) } },
6014#else
6015 { 0, 0, NoIntrinsic, { 0, 0 } },
6016#endif
6017#if ENABLE(POINTER_LOCK)
6018 { "pageHasPointerLock", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pageHasPointerLock), (intptr_t) (0) } },
6019#else
6020 { 0, 0, NoIntrinsic, { 0, 0 } },
6021#endif
6022 { "accessKeyModifiers", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_accessKeyModifiers), (intptr_t) (0) } },
6023 { "setQuickLookPassword", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setQuickLookPassword), (intptr_t) (1) } },
6024 { "setAsRunningUserScripts", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setAsRunningUserScripts), (intptr_t) (0) } },
6025#if ENABLE(APPLE_PAY)
6026 { "setApplePayIsActive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setApplePayIsActive), (intptr_t) (0) } },
6027#else
6028 { 0, 0, NoIntrinsic, { 0, 0 } },
6029#endif
6030 { "disableTileSizeUpdateDelay", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_disableTileSizeUpdateDelay), (intptr_t) (0) } },
6031 { "setSpeculativeTilingDelayDisabledForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setSpeculativeTilingDelayDisabledForTesting), (intptr_t) (1) } },
6032#if ENABLE(WEBGL)
6033 { "simulateEventForWebGLContext", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_simulateEventForWebGLContext), (intptr_t) (2) } },
6034#else
6035 { 0, 0, NoIntrinsic, { 0, 0 } },
6036#endif
6037#if ENABLE(WEBGL)
6038 { "hasLowAndHighPowerGPUs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_hasLowAndHighPowerGPUs), (intptr_t) (0) } },
6039#else
6040 { 0, 0, NoIntrinsic, { 0, 0 } },
6041#endif
6042 { "setPageVisibility", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setPageVisibility), (intptr_t) (1) } },
6043 { "setPageIsFocusedAndActive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setPageIsFocusedAndActive), (intptr_t) (1) } },
6044 { "setPageIsInWindow", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setPageIsInWindow), (intptr_t) (1) } },
6045 { "isPageActive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isPageActive), (intptr_t) (0) } },
6046#if ENABLE(WEB_RTC)
6047 { "setH264HardwareEncoderAllowed", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setH264HardwareEncoderAllowed), (intptr_t) (1) } },
6048#else
6049 { 0, 0, NoIntrinsic, { 0, 0 } },
6050#endif
6051#if ENABLE(WEB_RTC)
6052 { "applyRotationForOutgoingVideoSources", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_applyRotationForOutgoingVideoSources), (intptr_t) (1) } },
6053#else
6054 { 0, 0, NoIntrinsic, { 0, 0 } },
6055#endif
6056#if ENABLE(WEB_RTC)
6057 { "setWebRTCH265Support", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setWebRTCH265Support), (intptr_t) (1) } },
6058#else
6059 { 0, 0, NoIntrinsic, { 0, 0 } },
6060#endif
6061#if ENABLE(WEB_RTC)
6062 { "setWebRTCVP9Support", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setWebRTCVP9Support), (intptr_t) (2) } },
6063#else
6064 { 0, 0, NoIntrinsic, { 0, 0 } },
6065#endif
6066#if ENABLE(WEB_RTC)
6067 { "setWebRTCVP9VTBSupport", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setWebRTCVP9VTBSupport), (intptr_t) (1) } },
6068#else
6069 { 0, 0, NoIntrinsic, { 0, 0 } },
6070#endif
6071#if ENABLE(WEB_RTC)
6072 { "setSFrameCounter", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setSFrameCounter), (intptr_t) (2) } },
6073#else
6074 { 0, 0, NoIntrinsic, { 0, 0 } },
6075#endif
6076#if ENABLE(WEB_RTC)
6077 { "sframeCounter", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_sframeCounter), (intptr_t) (1) } },
6078#else
6079 { 0, 0, NoIntrinsic, { 0, 0 } },
6080#endif
6081#if ENABLE(WEB_RTC)
6082 { "sframeKeyId", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_sframeKeyId), (intptr_t) (1) } },
6083#else
6084 { 0, 0, NoIntrinsic, { 0, 0 } },
6085#endif
6086#if ENABLE(MEDIA_STREAM)
6087 { "setMockAudioTrackChannelNumber", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMockAudioTrackChannelNumber), (intptr_t) (2) } },
6088#else
6089 { 0, 0, NoIntrinsic, { 0, 0 } },
6090#endif
6091#if ENABLE(MEDIA_STREAM)
6092 { "setShouldInterruptAudioOnPageVisibilityChange", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setShouldInterruptAudioOnPageVisibilityChange), (intptr_t) (1) } },
6093#else
6094 { 0, 0, NoIntrinsic, { 0, 0 } },
6095#endif
6096#if ENABLE(MEDIA_STREAM)
6097 { "setCameraMediaStreamTrackOrientation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setCameraMediaStreamTrackOrientation), (intptr_t) (2) } },
6098#else
6099 { 0, 0, NoIntrinsic, { 0, 0 } },
6100#endif
6101#if ENABLE(MEDIA_STREAM)
6102 { "observeMediaStreamTrack", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_observeMediaStreamTrack), (intptr_t) (1) } },
6103#else
6104 { 0, 0, NoIntrinsic, { 0, 0 } },
6105#endif
6106#if ENABLE(MEDIA_STREAM)
6107 { "grabNextMediaStreamTrackFrame", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_grabNextMediaStreamTrackFrame), (intptr_t) (0) } },
6108#else
6109 { 0, 0, NoIntrinsic, { 0, 0 } },
6110#endif
6111#if ENABLE(MEDIA_STREAM)
6112 { "delayMediaStreamTrackSamples", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_delayMediaStreamTrackSamples), (intptr_t) (2) } },
6113#else
6114 { 0, 0, NoIntrinsic, { 0, 0 } },
6115#endif
6116#if ENABLE(MEDIA_STREAM)
6117 { "setMediaStreamTrackMuted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMediaStreamTrackMuted), (intptr_t) (2) } },
6118#else
6119 { 0, 0, NoIntrinsic, { 0, 0 } },
6120#endif
6121#if ENABLE(MEDIA_STREAM)
6122 { "removeMediaStreamTrack", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_removeMediaStreamTrack), (intptr_t) (2) } },
6123#else
6124 { 0, 0, NoIntrinsic, { 0, 0 } },
6125#endif
6126#if ENABLE(MEDIA_STREAM)
6127 { "simulateMediaStreamTrackCaptureSourceFailure", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_simulateMediaStreamTrackCaptureSourceFailure), (intptr_t) (1) } },
6128#else
6129 { 0, 0, NoIntrinsic, { 0, 0 } },
6130#endif
6131#if ENABLE(MEDIA_STREAM)
6132 { "setMediaStreamTrackIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMediaStreamTrackIdentifier), (intptr_t) (2) } },
6133#else
6134 { 0, 0, NoIntrinsic, { 0, 0 } },
6135#endif
6136#if ENABLE(MEDIA_STREAM)
6137 { "setMediaStreamSourceInterrupted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMediaStreamSourceInterrupted), (intptr_t) (2) } },
6138#else
6139 { 0, 0, NoIntrinsic, { 0, 0 } },
6140#endif
6141#if ENABLE(MEDIA_STREAM)
6142 { "isMediaStreamSourceInterrupted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isMediaStreamSourceInterrupted), (intptr_t) (1) } },
6143#else
6144 { 0, 0, NoIntrinsic, { 0, 0 } },
6145#endif
6146#if ENABLE(MEDIA_STREAM)
6147 { "isMediaStreamSourceEnded", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isMediaStreamSourceEnded), (intptr_t) (1) } },
6148#else
6149 { 0, 0, NoIntrinsic, { 0, 0 } },
6150#endif
6151#if ENABLE(MEDIA_STREAM)
6152 { "isMockRealtimeMediaSourceCenterEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isMockRealtimeMediaSourceCenterEnabled), (intptr_t) (0) } },
6153#else
6154 { 0, 0, NoIntrinsic, { 0, 0 } },
6155#endif
6156#if ENABLE(MEDIA_STREAM)
6157 { "shouldAudioTrackPlay", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_shouldAudioTrackPlay), (intptr_t) (1) } },
6158#else
6159 { 0, 0, NoIntrinsic, { 0, 0 } },
6160#endif
6161 { "documentIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_documentIdentifier), (intptr_t) (1) } },
6162 { "isDocumentAlive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isDocumentAlive), (intptr_t) (1) } },
6163 { "elementIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_elementIdentifier), (intptr_t) (1) } },
6164 { "isElementAlive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isElementAlive), (intptr_t) (1) } },
6165 { "frameIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_frameIdentifier), (intptr_t) (1) } },
6166 { "pageIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pageIdentifier), (intptr_t) (1) } },
6167 { "isAnyWorkletGlobalScopeAlive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isAnyWorkletGlobalScopeAlive), (intptr_t) (0) } },
6168 { "serviceWorkerClientIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_serviceWorkerClientIdentifier), (intptr_t) (1) } },
6169 { "storeRegistrationsOnDisk", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_storeRegistrationsOnDisk), (intptr_t) (0) } },
6170 { "sendH2Ping", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_sendH2Ping), (intptr_t) (1) } },
6171 { "clearCacheStorageMemoryRepresentation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_clearCacheStorageMemoryRepresentation), (intptr_t) (0) } },
6172 { "cacheStorageEngineRepresentation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_cacheStorageEngineRepresentation), (intptr_t) (0) } },
6173 { "setResponseSizeWithPadding", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setResponseSizeWithPadding), (intptr_t) (2) } },
6174 { "responseSizeWithPadding", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_responseSizeWithPadding), (intptr_t) (1) } },
6175 { "updateQuotaBasedOnSpaceUsage", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_updateQuotaBasedOnSpaceUsage), (intptr_t) (0) } },
6176 { "setConsoleMessageListener", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setConsoleMessageListener), (intptr_t) (1) } },
6177 { "audioSessionCategory", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_audioSessionCategory), (intptr_t) (0) } },
6178 { "preferredAudioBufferSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_preferredAudioBufferSize), (intptr_t) (0) } },
6179 { "currentAudioBufferSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_currentAudioBufferSize), (intptr_t) (0) } },
6180 { "audioSessionActive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_audioSessionActive), (intptr_t) (0) } },
6181#if ENABLE(SERVICE_WORKER)
6182 { "hasServiceWorkerRegistration", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_hasServiceWorkerRegistration), (intptr_t) (1) } },
6183#else
6184 { 0, 0, NoIntrinsic, { 0, 0 } },
6185#endif
6186#if ENABLE(SERVICE_WORKER)
6187 { "terminateServiceWorker", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_terminateServiceWorker), (intptr_t) (1) } },
6188#else
6189 { 0, 0, NoIntrinsic, { 0, 0 } },
6190#endif
6191#if ENABLE(SERVICE_WORKER)
6192 { "whenServiceWorkerIsTerminated", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_whenServiceWorkerIsTerminated), (intptr_t) (1) } },
6193#else
6194 { 0, 0, NoIntrinsic, { 0, 0 } },
6195#endif
6196 { "isSystemPreviewLink", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isSystemPreviewLink), (intptr_t) (1) } },
6197 { "isSystemPreviewImage", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isSystemPreviewImage), (intptr_t) (1) } },
6198 { "installImageOverlay", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_installImageOverlay), (intptr_t) (2) } },
6199 { "usingAppleInternalSDK", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_usingAppleInternalSDK), (intptr_t) (0) } },
6200 { "usingGStreamer", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_usingGStreamer), (intptr_t) (0) } },
6201 { "postTask", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_postTask), (intptr_t) (1) } },
6202 { "queueTask", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_queueTask), (intptr_t) (2) } },
6203 { "queueTaskToQueueMicrotask", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_queueTaskToQueueMicrotask), (intptr_t) (2) } },
6204 { "hasSameEventLoopAs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_hasSameEventLoopAs), (intptr_t) (1) } },
6205 { "windowLocationHost", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_windowLocationHost), (intptr_t) (1) } },
6206 { "markContextAsInsecure", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_markContextAsInsecure), (intptr_t) (0) } },
6207 { "setMaxCanvasPixelMemory", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMaxCanvasPixelMemory), (intptr_t) (1) } },
6208#if ENABLE(VIDEO)
6209 { "bestMediaElementForRemoteControls", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_bestMediaElementForRemoteControls), (intptr_t) (1) } },
6210#else
6211 { 0, 0, NoIntrinsic, { 0, 0 } },
6212#endif
6213#if ENABLE(VIDEO)
6214 { "mediaSessionState", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_mediaSessionState), (intptr_t) (1) } },
6215#else
6216 { 0, 0, NoIntrinsic, { 0, 0 } },
6217#endif
6218#if ENABLE(VIDEO)
6219 { "mediaUsageState", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_mediaUsageState), (intptr_t) (1) } },
6220#else
6221 { 0, 0, NoIntrinsic, { 0, 0 } },
6222#endif
6223#if ENABLE(VIDEO)
6224 { "elementShouldDisplayPosterImage", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_elementShouldDisplayPosterImage), (intptr_t) (1) } },
6225#else
6226 { 0, 0, NoIntrinsic, { 0, 0 } },
6227#endif
6228 { "ongoingLoadsDescriptions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_ongoingLoadsDescriptions), (intptr_t) (0) } },
6229 { "setCaptureExtraNetworkLoadMetricsEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setCaptureExtraNetworkLoadMetricsEnabled), (intptr_t) (1) } },
6230 { "reloadWithoutContentExtensions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_reloadWithoutContentExtensions), (intptr_t) (0) } },
6231 { "setUseSystemAppearance", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setUseSystemAppearance), (intptr_t) (1) } },
6232 { "pluginCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_pluginCount), (intptr_t) (0) } },
6233 { "notifyResourceLoadObserver", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_notifyResourceLoadObserver), (intptr_t) (0) } },
6234 { "primaryScreenDisplayID", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_primaryScreenDisplayID), (intptr_t) (0) } },
6235 { "capsLockIsOn", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_capsLockIsOn), (intptr_t) (0) } },
6236 { "parseHEVCCodecParameters", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_parseHEVCCodecParameters), (intptr_t) (1) } },
6237 { "parseDoViCodecParameters", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_parseDoViCodecParameters), (intptr_t) (1) } },
6238 { "parseVPCodecParameters", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_parseVPCodecParameters), (intptr_t) (1) } },
6239 { "getCookies", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_getCookies), (intptr_t) (0) } },
6240 { "setAlwaysAllowLocalWebarchive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setAlwaysAllowLocalWebarchive), (intptr_t) (1) } },
6241 { "processWillSuspend", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_processWillSuspend), (intptr_t) (0) } },
6242 { "processDidResume", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_processDidResume), (intptr_t) (0) } },
6243 { "testDictionaryLogging", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_testDictionaryLogging), (intptr_t) (0) } },
6244 { "setMaximumIntervalForUserGestureForwardingForFetch", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMaximumIntervalForUserGestureForwardingForFetch), (intptr_t) (1) } },
6245 { "setTransientActivationDuration", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setTransientActivationDuration), (intptr_t) (1) } },
6246 { "setIsPlayingToAutomotiveHeadUnit", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setIsPlayingToAutomotiveHeadUnit), (intptr_t) (1) } },
6247 { "textIndicatorForRange", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_textIndicatorForRange), (intptr_t) (2) } },
6248 { "addPrefetchLoadEventListener", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_addPrefetchLoadEventListener), (intptr_t) (2) } },
6249#if ENABLE(WEB_AUTHN)
6250 { "setMockWebAuthenticationConfiguration", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMockWebAuthenticationConfiguration), (intptr_t) (1) } },
6251#else
6252 { 0, 0, NoIntrinsic, { 0, 0 } },
6253#endif
6254 { "createInternalsMapLike", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_createInternalsMapLike), (intptr_t) (0) } },
6255 { "createInternalsSetLike", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_createInternalsSetLike), (intptr_t) (0) } },
6256 { "highlightPseudoElementColor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_highlightPseudoElementColor), (intptr_t) (2) } },
6257 { "hasSandboxMachLookupAccessToGlobalName", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_hasSandboxMachLookupAccessToGlobalName), (intptr_t) (2) } },
6258 { "hasSandboxMachLookupAccessToXPCServiceName", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_hasSandboxMachLookupAccessToXPCServiceName), (intptr_t) (2) } },
6259 { "hasSandboxIOKitOpenAccessToClass", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_hasSandboxIOKitOpenAccessToClass), (intptr_t) (2) } },
6260 { "systemColorForCSSValue", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_systemColorForCSSValue), (intptr_t) (3) } },
6261 { "focusRingColor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_focusRingColor), (intptr_t) (0) } },
6262 { "systemHasBattery", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_systemHasBattery), (intptr_t) (0) } },
6263 { "setSystemHasBatteryForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setSystemHasBatteryForTesting), (intptr_t) (1) } },
6264 { "setSystemHasACForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setSystemHasACForTesting), (intptr_t) (1) } },
6265 { "setHardwareVP9DecoderDisabledForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setHardwareVP9DecoderDisabledForTesting), (intptr_t) (1) } },
6266 { "setVP9ScreenSizeAndScaleForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setVP9ScreenSizeAndScaleForTesting), (intptr_t) (3) } },
6267 { "readPreferenceInteger", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_readPreferenceInteger), (intptr_t) (2) } },
6268 { "encodedPreferenceValue", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_encodedPreferenceValue), (intptr_t) (2) } },
6269 { "getUTIFromTag", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_getUTIFromTag), (intptr_t) (3) } },
6270 { "supportsPictureInPicture", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_supportsPictureInPicture), (intptr_t) (0) } },
6271 { "isRemoteUIAppForAccessibility", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_isRemoteUIAppForAccessibility), (intptr_t) (0) } },
6272 { "createSleepDisabler", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_createSleepDisabler), (intptr_t) (2) } },
6273 { "destroySleepDisabler", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_destroySleepDisabler), (intptr_t) (1) } },
6274#if ENABLE(APP_HIGHLIGHTS)
6275 { "numberOfAppHighlights", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_numberOfAppHighlights), (intptr_t) (0) } },
6276#else
6277 { 0, 0, NoIntrinsic, { 0, 0 } },
6278#endif
6279#if ENABLE(ENCRYPTED_MEDIA)
6280 { "mediaKeysInternalInstanceObjectRefCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_mediaKeysInternalInstanceObjectRefCount), (intptr_t) (1) } },
6281#else
6282 { 0, 0, NoIntrinsic, { 0, 0 } },
6283#endif
6284#if ENABLE(ENCRYPTED_MEDIA)
6285 { "mediaKeySessionInternalInstanceSessionObjectRefCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_mediaKeySessionInternalInstanceSessionObjectRefCount), (intptr_t) (1) } },
6286#else
6287 { 0, 0, NoIntrinsic, { 0, 0 } },
6288#endif
6289 { "setContentSizeCategory", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setContentSizeCategory), (intptr_t) (1) } },
6290#if ENABLE(ATTACHMENT_ELEMENT)
6291 { "attachmentThumbnailInfo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_attachmentThumbnailInfo), (intptr_t) (1) } },
6292#else
6293 { 0, 0, NoIntrinsic, { 0, 0 } },
6294#endif
6295#if ENABLE(MEDIA_SESSION)
6296 { "currentMediaSessionPosition", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_currentMediaSessionPosition), (intptr_t) (1) } },
6297#else
6298 { 0, 0, NoIntrinsic, { 0, 0 } },
6299#endif
6300#if ENABLE(MEDIA_SESSION)
6301 { "sendMediaSessionAction", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_sendMediaSessionAction), (intptr_t) (2) } },
6302#else
6303 { 0, 0, NoIntrinsic, { 0, 0 } },
6304#endif
6305#if ENABLE(MEDIA_SESSION)
6306 { "loadArtworkImage", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_loadArtworkImage), (intptr_t) (1) } },
6307#else
6308 { 0, 0, NoIntrinsic, { 0, 0 } },
6309#endif
6310#if ENABLE(MEDIA_SESSION_COORDINATOR)
6311 { "registerMockMediaSessionCoordinator", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_registerMockMediaSessionCoordinator), (intptr_t) (1) } },
6312#else
6313 { 0, 0, NoIntrinsic, { 0, 0 } },
6314#endif
6315#if ENABLE(MEDIA_SESSION_COORDINATOR)
6316 { "setMockMediaSessionCoordinatorCommandsShouldFail", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setMockMediaSessionCoordinatorCommandsShouldFail), (intptr_t) (1) } },
6317#else
6318 { 0, 0, NoIntrinsic, { 0, 0 } },
6319#endif
6320 { "treeOrder", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_treeOrder), (intptr_t) (2) } },
6321 { "treeOrderBoundaryPoints", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_treeOrderBoundaryPoints), (intptr_t) (4) } },
6322 { "rangeContainsNode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_rangeContainsNode), (intptr_t) (2) } },
6323 { "rangeContainsRange", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_rangeContainsRange), (intptr_t) (2) } },
6324 { "rangeContainsBoundaryPoint", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_rangeContainsBoundaryPoint), (intptr_t) (3) } },
6325 { "rangeIntersectsNode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_rangeIntersectsNode), (intptr_t) (2) } },
6326 { "rangeIntersectsRange", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_rangeIntersectsRange), (intptr_t) (2) } },
6327 { "systemBeep", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_systemBeep), (intptr_t) (0) } },
6328 { "dumpStyleResolvers", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_dumpStyleResolvers), (intptr_t) (0) } },
6329 { "setDocumentAutoplayPolicy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunction_setDocumentAutoplayPolicy), (intptr_t) (2) } },
6330 { "LAYER_TREE_INCLUDES_VISIBLE_RECTS", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(1) } },
6331 { "LAYER_TREE_INCLUDES_TILE_CACHES", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(2) } },
6332 { "LAYER_TREE_INCLUDES_REPAINT_RECTS", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(4) } },
6333 { "LAYER_TREE_INCLUDES_PAINTING_PHASES", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(8) } },
6334 { "LAYER_TREE_INCLUDES_CONTENT_LAYERS", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(16) } },
6335 { "LAYER_TREE_INCLUDES_ACCELERATES_DRAWING", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(32) } },
6336 { "LAYER_TREE_INCLUDES_CLIPPING", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(64) } },
6337 { "LAYER_TREE_INCLUDES_BACKING_STORE_ATTACHED", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(128) } },
6338 { "LAYER_TREE_INCLUDES_ROOT_LAYER_PROPERTIES", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(256) } },
6339 { "LAYER_TREE_INCLUDES_EVENT_REGION", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(512) } },
6340 { "LAYER_TREE_INCLUDES_DEEP_COLOR", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(1024) } },
6341 { "PLATFORM_LAYER_TREE_DEBUG", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(1) } },
6342 { "PLATFORM_LAYER_TREE_IGNORES_CHILDREN", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(2) } },
6343 { "PLATFORM_LAYER_TREE_INCLUDE_MODELS", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(4) } },
6344 { "DISPLAY_LIST_INCLUDES_PLATFORM_OPERATIONS", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(1) } },
6345};
6346
6347static const HashTable JSInternalsPrototypeTable = { 523, 2047, true, JSInternals::info(), JSInternalsPrototypeTableValues, JSInternalsPrototypeTableIndex };
6348const ClassInfo JSInternalsPrototype::s_info = { "Internals", &Base::s_info, &JSInternalsPrototypeTable, nullptr, CREATE_METHOD_TABLE(JSInternalsPrototype) };
6349
6350void JSInternalsPrototype::finishCreation(VM& vm)
6351{
6352 Base::finishCreation(vm);
6353 reifyStaticProperties(vm, JSInternals::info(), JSInternalsPrototypeTableValues, *this);
6354 JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
6355}
6356
6357const ClassInfo JSInternals::s_info = { "Internals", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSInternals) };
6358
6359JSInternals::JSInternals(Structure* structure, JSDOMGlobalObject& globalObject, Ref<Internals>&& impl)
6360 : JSDOMWrapper<Internals>(structure, globalObject, WTFMove(impl))
6361{
6362}
6363
6364void JSInternals::finishCreation(VM& vm)
6365{
6366 Base::finishCreation(vm);
6367 ASSERT(inherits(vm, info()));
6368
6369 static_assert(!std::is_base_of<ActiveDOMObject, Internals>::value, "Interface is not marked as [ActiveDOMObject] even though implementation class subclasses ActiveDOMObject.");
6370
6371}
6372
6373JSObject* JSInternals::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
6374{
6375 return JSInternalsPrototype::create(vm, &globalObject, JSInternalsPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
6376}
6377
6378JSObject* JSInternals::prototype(VM& vm, JSDOMGlobalObject& globalObject)
6379{
6380 return getDOMPrototype<JSInternals>(vm, globalObject);
6381}
6382
6383void JSInternals::destroy(JSC::JSCell* cell)
6384{
6385 JSInternals* thisObject = static_cast<JSInternals*>(cell);
6386 thisObject->JSInternals::~JSInternals();
6387}
6388
6389static inline JSValue jsInternals_inflightBeaconsCountGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6390{
6391 auto& vm = JSC::getVM(&lexicalGlobalObject);
6392 auto throwScope = DECLARE_THROW_SCOPE(vm);
6393 auto& impl = thisObject.wrapped();
6394 RELEASE_AND_RETURN(throwScope, (toJS<IDLUnsignedLong>(lexicalGlobalObject, throwScope, impl.inflightBeaconsCount())));
6395}
6396
6397JSC_DEFINE_CUSTOM_GETTER(jsInternals_inflightBeaconsCount, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6398{
6399 return IDLAttribute<JSInternals>::get<jsInternals_inflightBeaconsCountGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6400}
6401
6402static inline JSValue jsInternals_animationsIntervalGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6403{
6404 auto& vm = JSC::getVM(&lexicalGlobalObject);
6405 auto throwScope = DECLARE_THROW_SCOPE(vm);
6406 auto& impl = thisObject.wrapped();
6407 RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.animationsInterval())));
6408}
6409
6410JSC_DEFINE_CUSTOM_GETTER(jsInternals_animationsInterval, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6411{
6412 return IDLAttribute<JSInternals>::get<jsInternals_animationsIntervalGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6413}
6414
6415static inline JSValue jsInternals_sentenceRetroCorrectionEnabledGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6416{
6417 auto& vm = JSC::getVM(&lexicalGlobalObject);
6418 auto throwScope = DECLARE_THROW_SCOPE(vm);
6419 auto& impl = thisObject.wrapped();
6420 RELEASE_AND_RETURN(throwScope, (toJS<IDLBoolean>(lexicalGlobalObject, throwScope, impl.sentenceRetroCorrectionEnabled())));
6421}
6422
6423JSC_DEFINE_CUSTOM_GETTER(jsInternals_sentenceRetroCorrectionEnabled, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6424{
6425 return IDLAttribute<JSInternals>::get<jsInternals_sentenceRetroCorrectionEnabledGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6426}
6427
6428static inline JSValue jsInternals_settingsGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6429{
6430 auto& vm = JSC::getVM(&lexicalGlobalObject);
6431 auto throwScope = DECLARE_THROW_SCOPE(vm);
6432 auto& impl = thisObject.wrapped();
6433 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<InternalSettings>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.settings())));
6434}
6435
6436JSC_DEFINE_CUSTOM_GETTER(jsInternals_settings, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6437{
6438 return IDLAttribute<JSInternals>::get<jsInternals_settingsGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6439}
6440
6441static inline JSValue jsInternals_workerThreadCountGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6442{
6443 auto& vm = JSC::getVM(&lexicalGlobalObject);
6444 auto throwScope = DECLARE_THROW_SCOPE(vm);
6445 auto& impl = thisObject.wrapped();
6446 RELEASE_AND_RETURN(throwScope, (toJS<IDLUnsignedLong>(lexicalGlobalObject, throwScope, impl.workerThreadCount())));
6447}
6448
6449JSC_DEFINE_CUSTOM_GETTER(jsInternals_workerThreadCount, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6450{
6451 return IDLAttribute<JSInternals>::get<jsInternals_workerThreadCountGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6452}
6453
6454static inline JSValue jsInternals_areSVGAnimationsPausedGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6455{
6456 auto& vm = JSC::getVM(&lexicalGlobalObject);
6457 auto throwScope = DECLARE_THROW_SCOPE(vm);
6458 auto& impl = thisObject.wrapped();
6459 RELEASE_AND_RETURN(throwScope, (toJS<IDLBoolean>(lexicalGlobalObject, throwScope, impl.areSVGAnimationsPaused())));
6460}
6461
6462JSC_DEFINE_CUSTOM_GETTER(jsInternals_areSVGAnimationsPaused, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6463{
6464 return IDLAttribute<JSInternals>::get<jsInternals_areSVGAnimationsPausedGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6465}
6466
6467static inline JSValue jsInternals_isUnderMemoryPressureGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6468{
6469 auto& vm = JSC::getVM(&lexicalGlobalObject);
6470 auto throwScope = DECLARE_THROW_SCOPE(vm);
6471 auto& impl = thisObject.wrapped();
6472 RELEASE_AND_RETURN(throwScope, (toJS<IDLBoolean>(lexicalGlobalObject, throwScope, impl.isUnderMemoryPressure())));
6473}
6474
6475JSC_DEFINE_CUSTOM_GETTER(jsInternals_isUnderMemoryPressure, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6476{
6477 return IDLAttribute<JSInternals>::get<jsInternals_isUnderMemoryPressureGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6478}
6479
6480#if ENABLE(FULLSCREEN_API)
6481static inline JSValue jsInternals_isAnimatingFullScreenGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6482{
6483 auto& vm = JSC::getVM(&lexicalGlobalObject);
6484 auto throwScope = DECLARE_THROW_SCOPE(vm);
6485 auto& impl = thisObject.wrapped();
6486 RELEASE_AND_RETURN(throwScope, (toJS<IDLBoolean>(lexicalGlobalObject, throwScope, impl.isAnimatingFullScreen())));
6487}
6488
6489JSC_DEFINE_CUSTOM_GETTER(jsInternals_isAnimatingFullScreen, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6490{
6491 return IDLAttribute<JSInternals>::get<jsInternals_isAnimatingFullScreenGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6492}
6493
6494#endif
6495
6496static inline JSValue jsInternals_requestAnimationFrameIntervalGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6497{
6498 auto& vm = JSC::getVM(&lexicalGlobalObject);
6499 auto throwScope = DECLARE_THROW_SCOPE(vm);
6500 auto& impl = thisObject.wrapped();
6501 RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.requestAnimationFrameInterval())));
6502}
6503
6504JSC_DEFINE_CUSTOM_GETTER(jsInternals_requestAnimationFrameInterval, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6505{
6506 return IDLAttribute<JSInternals>::get<jsInternals_requestAnimationFrameIntervalGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6507}
6508
6509static inline JSValue jsInternals_scriptedAnimationsAreSuspendedGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6510{
6511 auto& vm = JSC::getVM(&lexicalGlobalObject);
6512 auto throwScope = DECLARE_THROW_SCOPE(vm);
6513 auto& impl = thisObject.wrapped();
6514 RELEASE_AND_RETURN(throwScope, (toJS<IDLBoolean>(lexicalGlobalObject, throwScope, impl.scriptedAnimationsAreSuspended())));
6515}
6516
6517JSC_DEFINE_CUSTOM_GETTER(jsInternals_scriptedAnimationsAreSuspended, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6518{
6519 return IDLAttribute<JSInternals>::get<jsInternals_scriptedAnimationsAreSuspendedGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6520}
6521
6522static inline JSValue jsInternals_eventThrottlingBehaviorOverrideGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6523{
6524 auto& vm = JSC::getVM(&lexicalGlobalObject);
6525 auto throwScope = DECLARE_THROW_SCOPE(vm);
6526 auto& impl = thisObject.wrapped();
6527 RELEASE_AND_RETURN(throwScope, (toJS<IDLNullable<IDLEnumeration<Internals::EventThrottlingBehavior>>>(lexicalGlobalObject, throwScope, impl.eventThrottlingBehaviorOverride())));
6528}
6529
6530JSC_DEFINE_CUSTOM_GETTER(jsInternals_eventThrottlingBehaviorOverride, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6531{
6532 return IDLAttribute<JSInternals>::get<jsInternals_eventThrottlingBehaviorOverrideGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6533}
6534
6535static inline bool setJSInternals_eventThrottlingBehaviorOverrideSetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject, JSValue value)
6536{
6537 auto& vm = JSC::getVM(&lexicalGlobalObject);
6538 auto throwScope = DECLARE_THROW_SCOPE(vm);
6539 auto& impl = thisObject.wrapped();
6540 auto optionalNativeValue = parseEnumeration<Internals::EventThrottlingBehavior>(lexicalGlobalObject, value);
6541 RETURN_IF_EXCEPTION(throwScope, false);
6542 if (UNLIKELY(!optionalNativeValue))
6543 return false;
6544 auto nativeValue = optionalNativeValue.value();
6545 invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
6546 return impl.setEventThrottlingBehaviorOverride(WTFMove(nativeValue));
6547 });
6548 return true;
6549}
6550
6551JSC_DEFINE_CUSTOM_SETTER(setJSInternals_eventThrottlingBehaviorOverride, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
6552{
6553 return IDLAttribute<JSInternals>::set<setJSInternals_eventThrottlingBehaviorOverrideSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
6554}
6555
6556static inline JSValue jsInternals_lastStyleUpdateSizeGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6557{
6558 auto& vm = JSC::getVM(&lexicalGlobalObject);
6559 auto throwScope = DECLARE_THROW_SCOPE(vm);
6560 auto& impl = thisObject.wrapped();
6561 RELEASE_AND_RETURN(throwScope, (toJS<IDLUnsignedLong>(lexicalGlobalObject, throwScope, impl.lastStyleUpdateSize())));
6562}
6563
6564JSC_DEFINE_CUSTOM_GETTER(jsInternals_lastStyleUpdateSize, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6565{
6566 return IDLAttribute<JSInternals>::get<jsInternals_lastStyleUpdateSizeGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6567}
6568
6569static inline JSValue jsInternals_compositingPolicyOverrideGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6570{
6571 auto& vm = JSC::getVM(&lexicalGlobalObject);
6572 auto throwScope = DECLARE_THROW_SCOPE(vm);
6573 auto& impl = thisObject.wrapped();
6574 RELEASE_AND_RETURN(throwScope, (toJS<IDLNullable<IDLEnumeration<Internals::CompositingPolicy>>>(lexicalGlobalObject, throwScope, impl.compositingPolicyOverride())));
6575}
6576
6577JSC_DEFINE_CUSTOM_GETTER(jsInternals_compositingPolicyOverride, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6578{
6579 return IDLAttribute<JSInternals>::get<jsInternals_compositingPolicyOverrideGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6580}
6581
6582static inline bool setJSInternals_compositingPolicyOverrideSetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject, JSValue value)
6583{
6584 auto& vm = JSC::getVM(&lexicalGlobalObject);
6585 auto throwScope = DECLARE_THROW_SCOPE(vm);
6586 auto& impl = thisObject.wrapped();
6587 auto optionalNativeValue = parseEnumeration<Internals::CompositingPolicy>(lexicalGlobalObject, value);
6588 RETURN_IF_EXCEPTION(throwScope, false);
6589 if (UNLIKELY(!optionalNativeValue))
6590 return false;
6591 auto nativeValue = optionalNativeValue.value();
6592 invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
6593 return impl.setCompositingPolicyOverride(WTFMove(nativeValue));
6594 });
6595 return true;
6596}
6597
6598JSC_DEFINE_CUSTOM_SETTER(setJSInternals_compositingPolicyOverride, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
6599{
6600 return IDLAttribute<JSInternals>::set<setJSInternals_compositingPolicyOverrideSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
6601}
6602
6603static inline JSValue jsInternals_layoutCountGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6604{
6605 auto& vm = JSC::getVM(&lexicalGlobalObject);
6606 auto throwScope = DECLARE_THROW_SCOPE(vm);
6607 auto& impl = thisObject.wrapped();
6608 RELEASE_AND_RETURN(throwScope, (toJS<IDLUnsignedLong>(lexicalGlobalObject, throwScope, impl.layoutCount())));
6609}
6610
6611JSC_DEFINE_CUSTOM_GETTER(jsInternals_layoutCount, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6612{
6613 return IDLAttribute<JSInternals>::get<jsInternals_layoutCountGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6614}
6615
6616#if ENABLE(CONTENT_FILTERING)
6617static inline JSValue jsInternals_mockContentFilterSettingsGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6618{
6619 auto& vm = JSC::getVM(&lexicalGlobalObject);
6620 auto throwScope = DECLARE_THROW_SCOPE(vm);
6621 auto& impl = thisObject.wrapped();
6622 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<MockContentFilterSettings>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.mockContentFilterSettings())));
6623}
6624
6625JSC_DEFINE_CUSTOM_GETTER(jsInternals_mockContentFilterSettings, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6626{
6627 return IDLAttribute<JSInternals>::get<jsInternals_mockContentFilterSettingsGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6628}
6629
6630#endif
6631
6632#if ENABLE(MEDIA_STREAM)
6633static inline JSValue jsInternals_trackAudioSampleCountGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6634{
6635 auto& vm = JSC::getVM(&lexicalGlobalObject);
6636 auto throwScope = DECLARE_THROW_SCOPE(vm);
6637 auto& impl = thisObject.wrapped();
6638 RELEASE_AND_RETURN(throwScope, (toJS<IDLUnsignedLong>(lexicalGlobalObject, throwScope, impl.trackAudioSampleCount())));
6639}
6640
6641JSC_DEFINE_CUSTOM_GETTER(jsInternals_trackAudioSampleCount, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6642{
6643 return IDLAttribute<JSInternals>::get<jsInternals_trackAudioSampleCountGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6644}
6645
6646#endif
6647
6648#if ENABLE(MEDIA_STREAM)
6649static inline JSValue jsInternals_trackVideoSampleCountGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6650{
6651 auto& vm = JSC::getVM(&lexicalGlobalObject);
6652 auto throwScope = DECLARE_THROW_SCOPE(vm);
6653 auto& impl = thisObject.wrapped();
6654 RELEASE_AND_RETURN(throwScope, (toJS<IDLUnsignedLong>(lexicalGlobalObject, throwScope, impl.trackVideoSampleCount())));
6655}
6656
6657JSC_DEFINE_CUSTOM_GETTER(jsInternals_trackVideoSampleCount, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6658{
6659 return IDLAttribute<JSInternals>::get<jsInternals_trackVideoSampleCountGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6660}
6661
6662#endif
6663
6664static inline JSValue jsInternals_storageAreaMapCountGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6665{
6666 auto& vm = JSC::getVM(&lexicalGlobalObject);
6667 auto throwScope = DECLARE_THROW_SCOPE(vm);
6668 auto& impl = thisObject.wrapped();
6669 RELEASE_AND_RETURN(throwScope, (toJS<IDLUnsignedLongLong>(lexicalGlobalObject, throwScope, impl.storageAreaMapCount())));
6670}
6671
6672JSC_DEFINE_CUSTOM_GETTER(jsInternals_storageAreaMapCount, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6673{
6674 return IDLAttribute<JSInternals>::get<jsInternals_storageAreaMapCountGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6675}
6676
6677static inline JSValue jsInternals_processIdentifierGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6678{
6679 auto& vm = JSC::getVM(&lexicalGlobalObject);
6680 auto throwScope = DECLARE_THROW_SCOPE(vm);
6681 auto& impl = thisObject.wrapped();
6682 RELEASE_AND_RETURN(throwScope, (toJS<IDLLong>(lexicalGlobalObject, throwScope, impl.processIdentifier())));
6683}
6684
6685JSC_DEFINE_CUSTOM_GETTER(jsInternals_processIdentifier, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6686{
6687 return IDLAttribute<JSInternals>::get<jsInternals_processIdentifierGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6688}
6689
6690static inline JSValue jsInternals_supportsAudioSessionGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6691{
6692 auto& vm = JSC::getVM(&lexicalGlobalObject);
6693 auto throwScope = DECLARE_THROW_SCOPE(vm);
6694 auto& impl = thisObject.wrapped();
6695 RELEASE_AND_RETURN(throwScope, (toJS<IDLBoolean>(lexicalGlobalObject, throwScope, impl.supportsAudioSession())));
6696}
6697
6698JSC_DEFINE_CUSTOM_GETTER(jsInternals_supportsAudioSession, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6699{
6700 return IDLAttribute<JSInternals>::get<jsInternals_supportsAudioSessionGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6701}
6702
6703#if ENABLE(APPLE_PAY)
6704static inline JSValue jsInternals_mockPaymentCoordinatorGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6705{
6706 auto& vm = JSC::getVM(&lexicalGlobalObject);
6707 auto throwScope = DECLARE_THROW_SCOPE(vm);
6708 auto* context = jsCast<JSDOMGlobalObject*>(&lexicalGlobalObject)->scriptExecutionContext();
6709 if (UNLIKELY(!context))
6710 return jsUndefined();
6711 ASSERT(context->isDocument());
6712 auto& document = downcast<Document>(*context);
6713 auto& impl = thisObject.wrapped();
6714 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<MockPaymentCoordinator>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.mockPaymentCoordinator(document))));
6715}
6716
6717JSC_DEFINE_CUSTOM_GETTER(jsInternals_mockPaymentCoordinator, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6718{
6719 return IDLAttribute<JSInternals>::get<jsInternals_mockPaymentCoordinatorGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6720}
6721
6722#endif
6723
6724#if ENABLE(VIDEO)
6725static inline JSValue jsInternals_nowPlayingStateGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6726{
6727 auto& vm = JSC::getVM(&lexicalGlobalObject);
6728 auto throwScope = DECLARE_THROW_SCOPE(vm);
6729 auto& impl = thisObject.wrapped();
6730 RELEASE_AND_RETURN(throwScope, (toJS<IDLDictionary<Internals::NowPlayingState>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.nowPlayingState())));
6731}
6732
6733JSC_DEFINE_CUSTOM_GETTER(jsInternals_nowPlayingState, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6734{
6735 return IDLAttribute<JSInternals>::get<jsInternals_nowPlayingStateGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6736}
6737
6738#endif
6739
6740#if ENABLE(VIDEO)
6741static inline JSValue jsInternals_mediaElementCountGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6742{
6743 auto& vm = JSC::getVM(&lexicalGlobalObject);
6744 auto throwScope = DECLARE_THROW_SCOPE(vm);
6745 auto& impl = thisObject.wrapped();
6746 RELEASE_AND_RETURN(throwScope, (toJS<IDLUnsignedLong>(lexicalGlobalObject, throwScope, impl.mediaElementCount())));
6747}
6748
6749JSC_DEFINE_CUSTOM_GETTER(jsInternals_mediaElementCount, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6750{
6751 return IDLAttribute<JSInternals>::get<jsInternals_mediaElementCountGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6752}
6753
6754#endif
6755
6756#if ENABLE(APP_HIGHLIGHTS)
6757static inline JSValue jsInternals_appHighlightContextMenuItemTitlesGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6758{
6759 auto& vm = JSC::getVM(&lexicalGlobalObject);
6760 auto throwScope = DECLARE_THROW_SCOPE(vm);
6761 auto& impl = thisObject.wrapped();
6762 RELEASE_AND_RETURN(throwScope, (toJS<IDLSequence<IDLDOMString>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.appHighlightContextMenuItemTitles())));
6763}
6764
6765JSC_DEFINE_CUSTOM_GETTER(jsInternals_appHighlightContextMenuItemTitles, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6766{
6767 return IDLAttribute<JSInternals>::get<jsInternals_appHighlightContextMenuItemTitlesGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6768}
6769
6770#endif
6771
6772#if ENABLE(WEBXR)
6773static inline JSValue jsInternals_xrTestGetter(JSGlobalObject& lexicalGlobalObject, JSInternals& thisObject)
6774{
6775 auto& vm = JSC::getVM(&lexicalGlobalObject);
6776 auto throwScope = DECLARE_THROW_SCOPE(vm);
6777 auto& impl = thisObject.wrapped();
6778 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<WebXRTest>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.xrTest())));
6779}
6780
6781JSC_DEFINE_CUSTOM_GETTER(jsInternals_xrTest, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
6782{
6783 return IDLAttribute<JSInternals>::get<jsInternals_xrTestGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
6784}
6785
6786#endif
6787
6788static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_addressBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
6789{
6790 auto& vm = JSC::getVM(lexicalGlobalObject);
6791 auto throwScope = DECLARE_THROW_SCOPE(vm);
6792 UNUSED_PARAM(throwScope);
6793 UNUSED_PARAM(callFrame);
6794 auto& impl = castedThis->wrapped();
6795 if (UNLIKELY(callFrame->argumentCount() < 1))
6796 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
6797 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
6798 auto node = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "node", "Internals", "address", "Node"); });
6799 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6800 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.address(*node))));
6801}
6802
6803JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_address, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
6804{
6805 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_addressBody>(*lexicalGlobalObject, *callFrame, "address");
6806}
6807
6808static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_nodeNeedsStyleRecalcBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
6809{
6810 auto& vm = JSC::getVM(lexicalGlobalObject);
6811 auto throwScope = DECLARE_THROW_SCOPE(vm);
6812 UNUSED_PARAM(throwScope);
6813 UNUSED_PARAM(callFrame);
6814 auto& impl = castedThis->wrapped();
6815 if (UNLIKELY(callFrame->argumentCount() < 1))
6816 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
6817 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
6818 auto node = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "node", "Internals", "nodeNeedsStyleRecalc", "Node"); });
6819 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6820 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.nodeNeedsStyleRecalc(*node))));
6821}
6822
6823JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_nodeNeedsStyleRecalc, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
6824{
6825 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_nodeNeedsStyleRecalcBody>(*lexicalGlobalObject, *callFrame, "nodeNeedsStyleRecalc");
6826}
6827
6828static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_styleChangeTypeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
6829{
6830 auto& vm = JSC::getVM(lexicalGlobalObject);
6831 auto throwScope = DECLARE_THROW_SCOPE(vm);
6832 UNUSED_PARAM(throwScope);
6833 UNUSED_PARAM(callFrame);
6834 auto& impl = castedThis->wrapped();
6835 if (UNLIKELY(callFrame->argumentCount() < 1))
6836 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
6837 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
6838 auto node = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "node", "Internals", "styleChangeType", "Node"); });
6839 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6840 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.styleChangeType(*node))));
6841}
6842
6843JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_styleChangeType, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
6844{
6845 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_styleChangeTypeBody>(*lexicalGlobalObject, *callFrame, "styleChangeType");
6846}
6847
6848static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_descriptionBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
6849{
6850 auto& vm = JSC::getVM(lexicalGlobalObject);
6851 auto throwScope = DECLARE_THROW_SCOPE(vm);
6852 UNUSED_PARAM(throwScope);
6853 UNUSED_PARAM(callFrame);
6854 auto& impl = castedThis->wrapped();
6855 if (UNLIKELY(callFrame->argumentCount() < 1))
6856 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
6857 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
6858 auto value = convert<IDLAny>(*lexicalGlobalObject, argument0.value());
6859 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6860 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.description(WTFMove(value)))));
6861}
6862
6863JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_description, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
6864{
6865 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_descriptionBody>(*lexicalGlobalObject, *callFrame, "description");
6866}
6867
6868static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_logBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
6869{
6870 auto& vm = JSC::getVM(lexicalGlobalObject);
6871 auto throwScope = DECLARE_THROW_SCOPE(vm);
6872 UNUSED_PARAM(throwScope);
6873 UNUSED_PARAM(callFrame);
6874 auto& impl = castedThis->wrapped();
6875 if (UNLIKELY(callFrame->argumentCount() < 1))
6876 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
6877 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
6878 auto value = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
6879 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6880 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.log(WTFMove(value)); })));
6881}
6882
6883JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_log, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
6884{
6885 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_logBody>(*lexicalGlobalObject, *callFrame, "log");
6886}
6887
6888static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_hasPausedImageAnimationsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
6889{
6890 auto& vm = JSC::getVM(lexicalGlobalObject);
6891 auto throwScope = DECLARE_THROW_SCOPE(vm);
6892 UNUSED_PARAM(throwScope);
6893 UNUSED_PARAM(callFrame);
6894 auto& impl = castedThis->wrapped();
6895 if (UNLIKELY(callFrame->argumentCount() < 1))
6896 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
6897 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
6898 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "hasPausedImageAnimations", "Element"); });
6899 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6900 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.hasPausedImageAnimations(*element))));
6901}
6902
6903JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasPausedImageAnimations, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
6904{
6905 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_hasPausedImageAnimationsBody>(*lexicalGlobalObject, *callFrame, "hasPausedImageAnimations");
6906}
6907
6908static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isPaintingFrequentlyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
6909{
6910 auto& vm = JSC::getVM(lexicalGlobalObject);
6911 auto throwScope = DECLARE_THROW_SCOPE(vm);
6912 UNUSED_PARAM(throwScope);
6913 UNUSED_PARAM(callFrame);
6914 auto& impl = castedThis->wrapped();
6915 if (UNLIKELY(callFrame->argumentCount() < 1))
6916 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
6917 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
6918 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "isPaintingFrequently", "Element"); });
6919 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6920 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isPaintingFrequently(*element))));
6921}
6922
6923JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isPaintingFrequently, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
6924{
6925 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isPaintingFrequentlyBody>(*lexicalGlobalObject, *callFrame, "isPaintingFrequently");
6926}
6927
6928static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_incrementFrequentPaintCounterBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
6929{
6930 auto& vm = JSC::getVM(lexicalGlobalObject);
6931 auto throwScope = DECLARE_THROW_SCOPE(vm);
6932 UNUSED_PARAM(throwScope);
6933 UNUSED_PARAM(callFrame);
6934 auto& impl = castedThis->wrapped();
6935 if (UNLIKELY(callFrame->argumentCount() < 1))
6936 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
6937 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
6938 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "incrementFrequentPaintCounter", "Element"); });
6939 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6940 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.incrementFrequentPaintCounter(*element); })));
6941}
6942
6943JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_incrementFrequentPaintCounter, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
6944{
6945 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_incrementFrequentPaintCounterBody>(*lexicalGlobalObject, *callFrame, "incrementFrequentPaintCounter");
6946}
6947
6948static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_elementRenderTreeAsTextBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
6949{
6950 auto& vm = JSC::getVM(lexicalGlobalObject);
6951 auto throwScope = DECLARE_THROW_SCOPE(vm);
6952 UNUSED_PARAM(throwScope);
6953 UNUSED_PARAM(callFrame);
6954 auto& impl = castedThis->wrapped();
6955 if (UNLIKELY(callFrame->argumentCount() < 1))
6956 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
6957 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
6958 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "elementRenderTreeAsText", "Element"); });
6959 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6960 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.elementRenderTreeAsText(*element))));
6961}
6962
6963JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_elementRenderTreeAsText, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
6964{
6965 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_elementRenderTreeAsTextBody>(*lexicalGlobalObject, *callFrame, "elementRenderTreeAsText");
6966}
6967
6968static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isPreloadedBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
6969{
6970 auto& vm = JSC::getVM(lexicalGlobalObject);
6971 auto throwScope = DECLARE_THROW_SCOPE(vm);
6972 UNUSED_PARAM(throwScope);
6973 UNUSED_PARAM(callFrame);
6974 auto& impl = castedThis->wrapped();
6975 if (UNLIKELY(callFrame->argumentCount() < 1))
6976 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
6977 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
6978 auto url = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
6979 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6980 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isPreloaded(WTFMove(url)))));
6981}
6982
6983JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isPreloaded, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
6984{
6985 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isPreloadedBody>(*lexicalGlobalObject, *callFrame, "isPreloaded");
6986}
6987
6988static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isLoadingFromMemoryCacheBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
6989{
6990 auto& vm = JSC::getVM(lexicalGlobalObject);
6991 auto throwScope = DECLARE_THROW_SCOPE(vm);
6992 UNUSED_PARAM(throwScope);
6993 UNUSED_PARAM(callFrame);
6994 auto& impl = castedThis->wrapped();
6995 if (UNLIKELY(callFrame->argumentCount() < 1))
6996 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
6997 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
6998 auto url = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
6999 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7000 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isLoadingFromMemoryCache(WTFMove(url)))));
7001}
7002
7003JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isLoadingFromMemoryCache, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7004{
7005 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isLoadingFromMemoryCacheBody>(*lexicalGlobalObject, *callFrame, "isLoadingFromMemoryCache");
7006}
7007
7008static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_fetchResponseSourceBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7009{
7010 auto& vm = JSC::getVM(lexicalGlobalObject);
7011 auto throwScope = DECLARE_THROW_SCOPE(vm);
7012 UNUSED_PARAM(throwScope);
7013 UNUSED_PARAM(callFrame);
7014 auto& impl = castedThis->wrapped();
7015 if (UNLIKELY(callFrame->argumentCount() < 1))
7016 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7017 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7018 auto response = convert<IDLInterface<FetchResponse>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "response", "Internals", "fetchResponseSource", "FetchResponse"); });
7019 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7020 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.fetchResponseSource(*response))));
7021}
7022
7023JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_fetchResponseSource, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7024{
7025 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_fetchResponseSourceBody>(*lexicalGlobalObject, *callFrame, "fetchResponseSource");
7026}
7027
7028static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_xhrResponseSourceBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7029{
7030 auto& vm = JSC::getVM(lexicalGlobalObject);
7031 auto throwScope = DECLARE_THROW_SCOPE(vm);
7032 UNUSED_PARAM(throwScope);
7033 UNUSED_PARAM(callFrame);
7034 auto& impl = castedThis->wrapped();
7035 if (UNLIKELY(callFrame->argumentCount() < 1))
7036 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7037 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7038 auto xhr = convert<IDLInterface<XMLHttpRequest>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "xhr", "Internals", "xhrResponseSource", "XMLHttpRequest"); });
7039 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7040 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.xhrResponseSource(*xhr))));
7041}
7042
7043JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_xhrResponseSource, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7044{
7045 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_xhrResponseSourceBody>(*lexicalGlobalObject, *callFrame, "xhrResponseSource");
7046}
7047
7048static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isSharingStyleSheetContentsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7049{
7050 auto& vm = JSC::getVM(lexicalGlobalObject);
7051 auto throwScope = DECLARE_THROW_SCOPE(vm);
7052 UNUSED_PARAM(throwScope);
7053 UNUSED_PARAM(callFrame);
7054 auto& impl = castedThis->wrapped();
7055 if (UNLIKELY(callFrame->argumentCount() < 2))
7056 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7057 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7058 auto a = convert<IDLInterface<HTMLLinkElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "a", "Internals", "isSharingStyleSheetContents", "HTMLLinkElement"); });
7059 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7060 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
7061 auto b = convert<IDLInterface<HTMLLinkElement>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "b", "Internals", "isSharingStyleSheetContents", "HTMLLinkElement"); });
7062 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7063 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isSharingStyleSheetContents(*a, *b))));
7064}
7065
7066JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isSharingStyleSheetContents, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7067{
7068 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isSharingStyleSheetContentsBody>(*lexicalGlobalObject, *callFrame, "isSharingStyleSheetContents");
7069}
7070
7071static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isStyleSheetLoadingSubresourcesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7072{
7073 auto& vm = JSC::getVM(lexicalGlobalObject);
7074 auto throwScope = DECLARE_THROW_SCOPE(vm);
7075 UNUSED_PARAM(throwScope);
7076 UNUSED_PARAM(callFrame);
7077 auto& impl = castedThis->wrapped();
7078 if (UNLIKELY(callFrame->argumentCount() < 1))
7079 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7080 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7081 auto link = convert<IDLInterface<HTMLLinkElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "link", "Internals", "isStyleSheetLoadingSubresources", "HTMLLinkElement"); });
7082 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7083 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isStyleSheetLoadingSubresources(*link))));
7084}
7085
7086JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isStyleSheetLoadingSubresources, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7087{
7088 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isStyleSheetLoadingSubresourcesBody>(*lexicalGlobalObject, *callFrame, "isStyleSheetLoadingSubresources");
7089}
7090
7091static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_clearMemoryCacheBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7092{
7093 auto& vm = JSC::getVM(lexicalGlobalObject);
7094 auto throwScope = DECLARE_THROW_SCOPE(vm);
7095 UNUSED_PARAM(throwScope);
7096 UNUSED_PARAM(callFrame);
7097 auto& impl = castedThis->wrapped();
7098 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.clearMemoryCache(); })));
7099}
7100
7101JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_clearMemoryCache, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7102{
7103 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_clearMemoryCacheBody>(*lexicalGlobalObject, *callFrame, "clearMemoryCache");
7104}
7105
7106static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pruneMemoryCacheToSizeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7107{
7108 auto& vm = JSC::getVM(lexicalGlobalObject);
7109 auto throwScope = DECLARE_THROW_SCOPE(vm);
7110 UNUSED_PARAM(throwScope);
7111 UNUSED_PARAM(callFrame);
7112 auto& impl = castedThis->wrapped();
7113 if (UNLIKELY(callFrame->argumentCount() < 1))
7114 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7115 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7116 auto size = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
7117 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7118 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.pruneMemoryCacheToSize(WTFMove(size)); })));
7119}
7120
7121JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pruneMemoryCacheToSize, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7122{
7123 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pruneMemoryCacheToSizeBody>(*lexicalGlobalObject, *callFrame, "pruneMemoryCacheToSize");
7124}
7125
7126static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_destroyDecodedDataForAllImagesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7127{
7128 auto& vm = JSC::getVM(lexicalGlobalObject);
7129 auto throwScope = DECLARE_THROW_SCOPE(vm);
7130 UNUSED_PARAM(throwScope);
7131 UNUSED_PARAM(callFrame);
7132 auto& impl = castedThis->wrapped();
7133 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.destroyDecodedDataForAllImages(); })));
7134}
7135
7136JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_destroyDecodedDataForAllImages, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7137{
7138 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_destroyDecodedDataForAllImagesBody>(*lexicalGlobalObject, *callFrame, "destroyDecodedDataForAllImages");
7139}
7140
7141static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_memoryCacheSizeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7142{
7143 auto& vm = JSC::getVM(lexicalGlobalObject);
7144 auto throwScope = DECLARE_THROW_SCOPE(vm);
7145 UNUSED_PARAM(throwScope);
7146 UNUSED_PARAM(callFrame);
7147 auto& impl = castedThis->wrapped();
7148 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLLong>(*lexicalGlobalObject, throwScope, impl.memoryCacheSize())));
7149}
7150
7151JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_memoryCacheSize, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7152{
7153 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_memoryCacheSizeBody>(*lexicalGlobalObject, *callFrame, "memoryCacheSize");
7154}
7155
7156static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setOverrideCachePolicyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7157{
7158 auto& vm = JSC::getVM(lexicalGlobalObject);
7159 auto throwScope = DECLARE_THROW_SCOPE(vm);
7160 UNUSED_PARAM(throwScope);
7161 UNUSED_PARAM(callFrame);
7162 auto& impl = castedThis->wrapped();
7163 if (UNLIKELY(callFrame->argumentCount() < 1))
7164 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7165 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7166 auto policy = convert<IDLEnumeration<Internals::CachePolicy>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 0, "policy", "Internals", "setOverrideCachePolicy", expectedEnumerationValues<Internals::CachePolicy>()); });
7167 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7168 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setOverrideCachePolicy(WTFMove(policy)); })));
7169}
7170
7171JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setOverrideCachePolicy, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7172{
7173 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setOverrideCachePolicyBody>(*lexicalGlobalObject, *callFrame, "setOverrideCachePolicy");
7174}
7175
7176static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setOverrideResourceLoadPriorityBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7177{
7178 auto& vm = JSC::getVM(lexicalGlobalObject);
7179 auto throwScope = DECLARE_THROW_SCOPE(vm);
7180 UNUSED_PARAM(throwScope);
7181 UNUSED_PARAM(callFrame);
7182 auto& impl = castedThis->wrapped();
7183 if (UNLIKELY(callFrame->argumentCount() < 1))
7184 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7185 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7186 auto priority = convert<IDLEnumeration<Internals::ResourceLoadPriority>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 0, "priority", "Internals", "setOverrideResourceLoadPriority", expectedEnumerationValues<Internals::ResourceLoadPriority>()); });
7187 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7188 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setOverrideResourceLoadPriority(WTFMove(priority)); })));
7189}
7190
7191JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setOverrideResourceLoadPriority, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7192{
7193 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setOverrideResourceLoadPriorityBody>(*lexicalGlobalObject, *callFrame, "setOverrideResourceLoadPriority");
7194}
7195
7196static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setStrictRawResourceValidationPolicyDisabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7197{
7198 auto& vm = JSC::getVM(lexicalGlobalObject);
7199 auto throwScope = DECLARE_THROW_SCOPE(vm);
7200 UNUSED_PARAM(throwScope);
7201 UNUSED_PARAM(callFrame);
7202 auto& impl = castedThis->wrapped();
7203 if (UNLIKELY(callFrame->argumentCount() < 1))
7204 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7205 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7206 auto disabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
7207 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7208 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setStrictRawResourceValidationPolicyDisabled(WTFMove(disabled)); })));
7209}
7210
7211JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setStrictRawResourceValidationPolicyDisabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7212{
7213 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setStrictRawResourceValidationPolicyDisabledBody>(*lexicalGlobalObject, *callFrame, "setStrictRawResourceValidationPolicyDisabled");
7214}
7215
7216static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_clearBackForwardCacheBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7217{
7218 auto& vm = JSC::getVM(lexicalGlobalObject);
7219 auto throwScope = DECLARE_THROW_SCOPE(vm);
7220 UNUSED_PARAM(throwScope);
7221 UNUSED_PARAM(callFrame);
7222 auto& impl = castedThis->wrapped();
7223 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.clearBackForwardCache(); })));
7224}
7225
7226JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_clearBackForwardCache, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7227{
7228 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_clearBackForwardCacheBody>(*lexicalGlobalObject, *callFrame, "clearBackForwardCache");
7229}
7230
7231static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_backForwardCacheSizeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7232{
7233 auto& vm = JSC::getVM(lexicalGlobalObject);
7234 auto throwScope = DECLARE_THROW_SCOPE(vm);
7235 UNUSED_PARAM(throwScope);
7236 UNUSED_PARAM(callFrame);
7237 auto& impl = castedThis->wrapped();
7238 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.backForwardCacheSize())));
7239}
7240
7241JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_backForwardCacheSize, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7242{
7243 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_backForwardCacheSizeBody>(*lexicalGlobalObject, *callFrame, "backForwardCacheSize");
7244}
7245
7246static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_preventDocumentFromEnteringBackForwardCacheBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7247{
7248 auto& vm = JSC::getVM(lexicalGlobalObject);
7249 auto throwScope = DECLARE_THROW_SCOPE(vm);
7250 UNUSED_PARAM(throwScope);
7251 UNUSED_PARAM(callFrame);
7252 auto& impl = castedThis->wrapped();
7253 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.preventDocumentFromEnteringBackForwardCache(); })));
7254}
7255
7256JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_preventDocumentFromEnteringBackForwardCache, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7257{
7258 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_preventDocumentFromEnteringBackForwardCacheBody>(*lexicalGlobalObject, *callFrame, "preventDocumentFromEnteringBackForwardCache");
7259}
7260
7261static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_computedStyleIncludingVisitedInfoBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7262{
7263 auto& vm = JSC::getVM(lexicalGlobalObject);
7264 auto throwScope = DECLARE_THROW_SCOPE(vm);
7265 UNUSED_PARAM(throwScope);
7266 UNUSED_PARAM(callFrame);
7267 auto& impl = castedThis->wrapped();
7268 if (UNLIKELY(callFrame->argumentCount() < 1))
7269 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7270 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7271 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "computedStyleIncludingVisitedInfo", "Element"); });
7272 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7273 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<CSSStyleDeclaration>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.computedStyleIncludingVisitedInfo(*element))));
7274}
7275
7276JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_computedStyleIncludingVisitedInfo, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7277{
7278 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_computedStyleIncludingVisitedInfoBody>(*lexicalGlobalObject, *callFrame, "computedStyleIncludingVisitedInfo");
7279}
7280
7281static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_ensureUserAgentShadowRootBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7282{
7283 auto& vm = JSC::getVM(lexicalGlobalObject);
7284 auto throwScope = DECLARE_THROW_SCOPE(vm);
7285 UNUSED_PARAM(throwScope);
7286 UNUSED_PARAM(callFrame);
7287 auto& impl = castedThis->wrapped();
7288 if (UNLIKELY(callFrame->argumentCount() < 1))
7289 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7290 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7291 auto host = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "host", "Internals", "ensureUserAgentShadowRoot", "Element"); });
7292 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7293 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<Node>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.ensureUserAgentShadowRoot(*host))));
7294}
7295
7296JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_ensureUserAgentShadowRoot, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7297{
7298 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_ensureUserAgentShadowRootBody>(*lexicalGlobalObject, *callFrame, "ensureUserAgentShadowRoot");
7299}
7300
7301static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_shadowRootBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7302{
7303 auto& vm = JSC::getVM(lexicalGlobalObject);
7304 auto throwScope = DECLARE_THROW_SCOPE(vm);
7305 UNUSED_PARAM(throwScope);
7306 UNUSED_PARAM(callFrame);
7307 auto& impl = castedThis->wrapped();
7308 if (UNLIKELY(callFrame->argumentCount() < 1))
7309 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7310 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7311 auto host = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "host", "Internals", "shadowRoot", "Element"); });
7312 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7313 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<Node>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.shadowRoot(*host))));
7314}
7315
7316JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_shadowRoot, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7317{
7318 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_shadowRootBody>(*lexicalGlobalObject, *callFrame, "shadowRoot");
7319}
7320
7321static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_deferredStyleRulesCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7322{
7323 auto& vm = JSC::getVM(lexicalGlobalObject);
7324 auto throwScope = DECLARE_THROW_SCOPE(vm);
7325 UNUSED_PARAM(throwScope);
7326 UNUSED_PARAM(callFrame);
7327 auto& impl = castedThis->wrapped();
7328 if (UNLIKELY(callFrame->argumentCount() < 1))
7329 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7330 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7331 auto sheet = convert<IDLInterface<StyleSheet>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "sheet", "Internals", "deferredStyleRulesCount", "StyleSheet"); });
7332 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7333 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLLong>(*lexicalGlobalObject, throwScope, impl.deferredStyleRulesCount(*sheet))));
7334}
7335
7336JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_deferredStyleRulesCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7337{
7338 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_deferredStyleRulesCountBody>(*lexicalGlobalObject, *callFrame, "deferredStyleRulesCount");
7339}
7340
7341static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_deferredGroupRulesCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7342{
7343 auto& vm = JSC::getVM(lexicalGlobalObject);
7344 auto throwScope = DECLARE_THROW_SCOPE(vm);
7345 UNUSED_PARAM(throwScope);
7346 UNUSED_PARAM(callFrame);
7347 auto& impl = castedThis->wrapped();
7348 if (UNLIKELY(callFrame->argumentCount() < 1))
7349 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7350 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7351 auto sheet = convert<IDLInterface<StyleSheet>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "sheet", "Internals", "deferredGroupRulesCount", "StyleSheet"); });
7352 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7353 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLLong>(*lexicalGlobalObject, throwScope, impl.deferredGroupRulesCount(*sheet))));
7354}
7355
7356JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_deferredGroupRulesCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7357{
7358 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_deferredGroupRulesCountBody>(*lexicalGlobalObject, *callFrame, "deferredGroupRulesCount");
7359}
7360
7361static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_deferredKeyframesRulesCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7362{
7363 auto& vm = JSC::getVM(lexicalGlobalObject);
7364 auto throwScope = DECLARE_THROW_SCOPE(vm);
7365 UNUSED_PARAM(throwScope);
7366 UNUSED_PARAM(callFrame);
7367 auto& impl = castedThis->wrapped();
7368 if (UNLIKELY(callFrame->argumentCount() < 1))
7369 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7370 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7371 auto sheet = convert<IDLInterface<StyleSheet>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "sheet", "Internals", "deferredKeyframesRulesCount", "StyleSheet"); });
7372 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7373 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLLong>(*lexicalGlobalObject, throwScope, impl.deferredKeyframesRulesCount(*sheet))));
7374}
7375
7376JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_deferredKeyframesRulesCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7377{
7378 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_deferredKeyframesRulesCountBody>(*lexicalGlobalObject, *callFrame, "deferredKeyframesRulesCount");
7379}
7380
7381static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_shadowRootTypeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7382{
7383 auto& vm = JSC::getVM(lexicalGlobalObject);
7384 auto throwScope = DECLARE_THROW_SCOPE(vm);
7385 UNUSED_PARAM(throwScope);
7386 UNUSED_PARAM(callFrame);
7387 auto& impl = castedThis->wrapped();
7388 if (UNLIKELY(callFrame->argumentCount() < 1))
7389 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7390 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7391 auto root = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "root", "Internals", "shadowRootType", "Node"); });
7392 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7393 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.shadowRootType(*root))));
7394}
7395
7396JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_shadowRootType, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7397{
7398 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_shadowRootTypeBody>(*lexicalGlobalObject, *callFrame, "shadowRootType");
7399}
7400
7401static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_shadowPseudoIdBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7402{
7403 auto& vm = JSC::getVM(lexicalGlobalObject);
7404 auto throwScope = DECLARE_THROW_SCOPE(vm);
7405 UNUSED_PARAM(throwScope);
7406 UNUSED_PARAM(callFrame);
7407 auto& impl = castedThis->wrapped();
7408 if (UNLIKELY(callFrame->argumentCount() < 1))
7409 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7410 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7411 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "shadowPseudoId", "Element"); });
7412 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7413 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.shadowPseudoId(*element))));
7414}
7415
7416JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_shadowPseudoId, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7417{
7418 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_shadowPseudoIdBody>(*lexicalGlobalObject, *callFrame, "shadowPseudoId");
7419}
7420
7421static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setShadowPseudoIdBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7422{
7423 auto& vm = JSC::getVM(lexicalGlobalObject);
7424 auto throwScope = DECLARE_THROW_SCOPE(vm);
7425 UNUSED_PARAM(throwScope);
7426 UNUSED_PARAM(callFrame);
7427 auto& impl = castedThis->wrapped();
7428 if (UNLIKELY(callFrame->argumentCount() < 2))
7429 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7430 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7431 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "setShadowPseudoId", "Element"); });
7432 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7433 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
7434 auto id = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
7435 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7436 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setShadowPseudoId(*element, WTFMove(id)); })));
7437}
7438
7439JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setShadowPseudoId, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7440{
7441 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setShadowPseudoIdBody>(*lexicalGlobalObject, *callFrame, "setShadowPseudoId");
7442}
7443
7444static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_treeScopeRootNodeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7445{
7446 auto& vm = JSC::getVM(lexicalGlobalObject);
7447 auto throwScope = DECLARE_THROW_SCOPE(vm);
7448 UNUSED_PARAM(throwScope);
7449 UNUSED_PARAM(callFrame);
7450 auto& impl = castedThis->wrapped();
7451 if (UNLIKELY(callFrame->argumentCount() < 1))
7452 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7453 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7454 auto node = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "node", "Internals", "treeScopeRootNode", "Node"); });
7455 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7456 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<Node>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.treeScopeRootNode(*node))));
7457}
7458
7459JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_treeScopeRootNode, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7460{
7461 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_treeScopeRootNodeBody>(*lexicalGlobalObject, *callFrame, "treeScopeRootNode");
7462}
7463
7464static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_parentTreeScopeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7465{
7466 auto& vm = JSC::getVM(lexicalGlobalObject);
7467 auto throwScope = DECLARE_THROW_SCOPE(vm);
7468 UNUSED_PARAM(throwScope);
7469 UNUSED_PARAM(callFrame);
7470 auto& impl = castedThis->wrapped();
7471 if (UNLIKELY(callFrame->argumentCount() < 1))
7472 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7473 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7474 auto node = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "node", "Internals", "parentTreeScope", "Node"); });
7475 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7476 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<Node>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.parentTreeScope(*node))));
7477}
7478
7479JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_parentTreeScope, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7480{
7481 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_parentTreeScopeBody>(*lexicalGlobalObject, *callFrame, "parentTreeScope");
7482}
7483
7484static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_lastSpatialNavigationCandidateCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7485{
7486 auto& vm = JSC::getVM(lexicalGlobalObject);
7487 auto throwScope = DECLARE_THROW_SCOPE(vm);
7488 UNUSED_PARAM(throwScope);
7489 UNUSED_PARAM(callFrame);
7490 auto& impl = castedThis->wrapped();
7491 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.lastSpatialNavigationCandidateCount())));
7492}
7493
7494JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_lastSpatialNavigationCandidateCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7495{
7496 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_lastSpatialNavigationCandidateCountBody>(*lexicalGlobalObject, *callFrame, "lastSpatialNavigationCandidateCount");
7497}
7498
7499static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_animationWithIdExistsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7500{
7501 auto& vm = JSC::getVM(lexicalGlobalObject);
7502 auto throwScope = DECLARE_THROW_SCOPE(vm);
7503 UNUSED_PARAM(throwScope);
7504 UNUSED_PARAM(callFrame);
7505 auto& impl = castedThis->wrapped();
7506 if (UNLIKELY(callFrame->argumentCount() < 1))
7507 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7508 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7509 auto id = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
7510 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7511 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.animationWithIdExists(WTFMove(id)))));
7512}
7513
7514JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_animationWithIdExists, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7515{
7516 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_animationWithIdExistsBody>(*lexicalGlobalObject, *callFrame, "animationWithIdExists");
7517}
7518
7519static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_numberOfActiveAnimationsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7520{
7521 auto& vm = JSC::getVM(lexicalGlobalObject);
7522 auto throwScope = DECLARE_THROW_SCOPE(vm);
7523 UNUSED_PARAM(throwScope);
7524 UNUSED_PARAM(callFrame);
7525 auto& impl = castedThis->wrapped();
7526 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.numberOfActiveAnimations())));
7527}
7528
7529JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfActiveAnimations, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7530{
7531 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_numberOfActiveAnimationsBody>(*lexicalGlobalObject, *callFrame, "numberOfActiveAnimations");
7532}
7533
7534static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_suspendAnimationsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7535{
7536 auto& vm = JSC::getVM(lexicalGlobalObject);
7537 auto throwScope = DECLARE_THROW_SCOPE(vm);
7538 UNUSED_PARAM(throwScope);
7539 UNUSED_PARAM(callFrame);
7540 auto& impl = castedThis->wrapped();
7541 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.suspendAnimations(); })));
7542}
7543
7544JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_suspendAnimations, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7545{
7546 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_suspendAnimationsBody>(*lexicalGlobalObject, *callFrame, "suspendAnimations");
7547}
7548
7549static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_resumeAnimationsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7550{
7551 auto& vm = JSC::getVM(lexicalGlobalObject);
7552 auto throwScope = DECLARE_THROW_SCOPE(vm);
7553 UNUSED_PARAM(throwScope);
7554 UNUSED_PARAM(callFrame);
7555 auto& impl = castedThis->wrapped();
7556 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.resumeAnimations(); })));
7557}
7558
7559JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_resumeAnimations, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7560{
7561 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_resumeAnimationsBody>(*lexicalGlobalObject, *callFrame, "resumeAnimations");
7562}
7563
7564static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_animationsAreSuspendedBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7565{
7566 auto& vm = JSC::getVM(lexicalGlobalObject);
7567 auto throwScope = DECLARE_THROW_SCOPE(vm);
7568 UNUSED_PARAM(throwScope);
7569 UNUSED_PARAM(callFrame);
7570 auto& impl = castedThis->wrapped();
7571 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.animationsAreSuspended())));
7572}
7573
7574JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_animationsAreSuspended, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7575{
7576 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_animationsAreSuspendedBody>(*lexicalGlobalObject, *callFrame, "animationsAreSuspended");
7577}
7578
7579static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_acceleratedAnimationsForElementBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7580{
7581 auto& vm = JSC::getVM(lexicalGlobalObject);
7582 auto throwScope = DECLARE_THROW_SCOPE(vm);
7583 UNUSED_PARAM(throwScope);
7584 UNUSED_PARAM(callFrame);
7585 auto& impl = castedThis->wrapped();
7586 if (UNLIKELY(callFrame->argumentCount() < 1))
7587 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7588 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7589 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "acceleratedAnimationsForElement", "Element"); });
7590 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7591 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLSequence<IDLDictionary<Internals::AcceleratedAnimation>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.acceleratedAnimationsForElement(*element))));
7592}
7593
7594JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_acceleratedAnimationsForElement, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7595{
7596 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_acceleratedAnimationsForElementBody>(*lexicalGlobalObject, *callFrame, "acceleratedAnimationsForElement");
7597}
7598
7599static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_numberOfAnimationTimelineInvalidationsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7600{
7601 auto& vm = JSC::getVM(lexicalGlobalObject);
7602 auto throwScope = DECLARE_THROW_SCOPE(vm);
7603 UNUSED_PARAM(throwScope);
7604 UNUSED_PARAM(callFrame);
7605 auto& impl = castedThis->wrapped();
7606 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.numberOfAnimationTimelineInvalidations())));
7607}
7608
7609JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfAnimationTimelineInvalidations, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7610{
7611 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_numberOfAnimationTimelineInvalidationsBody>(*lexicalGlobalObject, *callFrame, "numberOfAnimationTimelineInvalidations");
7612}
7613
7614static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_timeToNextAnimationTickBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7615{
7616 auto& vm = JSC::getVM(lexicalGlobalObject);
7617 auto throwScope = DECLARE_THROW_SCOPE(vm);
7618 UNUSED_PARAM(throwScope);
7619 UNUSED_PARAM(callFrame);
7620 auto& impl = castedThis->wrapped();
7621 if (UNLIKELY(callFrame->argumentCount() < 1))
7622 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7623 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7624 auto animation = convert<IDLInterface<WebAnimation>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "animation", "Internals", "timeToNextAnimationTick", "WebAnimation"); });
7625 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7626 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.timeToNextAnimationTick(*animation))));
7627}
7628
7629JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_timeToNextAnimationTick, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7630{
7631 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_timeToNextAnimationTickBody>(*lexicalGlobalObject, *callFrame, "timeToNextAnimationTick");
7632}
7633
7634static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pseudoElementBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7635{
7636 auto& vm = JSC::getVM(lexicalGlobalObject);
7637 auto throwScope = DECLARE_THROW_SCOPE(vm);
7638 UNUSED_PARAM(throwScope);
7639 UNUSED_PARAM(callFrame);
7640 auto& impl = castedThis->wrapped();
7641 if (UNLIKELY(callFrame->argumentCount() < 2))
7642 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7643 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7644 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "pseudoElement", "Element"); });
7645 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7646 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
7647 auto pseudoId = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
7648 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7649 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLInterface<Element>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.pseudoElement(*element, WTFMove(pseudoId)))));
7650}
7651
7652JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pseudoElement, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7653{
7654 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pseudoElementBody>(*lexicalGlobalObject, *callFrame, "pseudoElement");
7655}
7656
7657static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_visiblePlaceholderBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7658{
7659 auto& vm = JSC::getVM(lexicalGlobalObject);
7660 auto throwScope = DECLARE_THROW_SCOPE(vm);
7661 UNUSED_PARAM(throwScope);
7662 UNUSED_PARAM(callFrame);
7663 auto& impl = castedThis->wrapped();
7664 if (UNLIKELY(callFrame->argumentCount() < 1))
7665 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7666 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7667 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "visiblePlaceholder", "Element"); });
7668 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7669 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.visiblePlaceholder(*element))));
7670}
7671
7672JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_visiblePlaceholder, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7673{
7674 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_visiblePlaceholderBody>(*lexicalGlobalObject, *callFrame, "visiblePlaceholder");
7675}
7676
7677static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_selectColorInColorChooserBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7678{
7679 auto& vm = JSC::getVM(lexicalGlobalObject);
7680 auto throwScope = DECLARE_THROW_SCOPE(vm);
7681 UNUSED_PARAM(throwScope);
7682 UNUSED_PARAM(callFrame);
7683 auto& impl = castedThis->wrapped();
7684 if (UNLIKELY(callFrame->argumentCount() < 2))
7685 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7686 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7687 auto element = convert<IDLInterface<HTMLInputElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "selectColorInColorChooser", "HTMLInputElement"); });
7688 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7689 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
7690 auto colorValue = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
7691 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7692 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.selectColorInColorChooser(*element, WTFMove(colorValue)); })));
7693}
7694
7695JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_selectColorInColorChooser, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7696{
7697 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_selectColorInColorChooserBody>(*lexicalGlobalObject, *callFrame, "selectColorInColorChooser");
7698}
7699
7700static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_formControlStateOfPreviousHistoryItemBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7701{
7702 auto& vm = JSC::getVM(lexicalGlobalObject);
7703 auto throwScope = DECLARE_THROW_SCOPE(vm);
7704 UNUSED_PARAM(throwScope);
7705 UNUSED_PARAM(callFrame);
7706 auto& impl = castedThis->wrapped();
7707 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.formControlStateOfPreviousHistoryItem())));
7708}
7709
7710JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_formControlStateOfPreviousHistoryItem, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7711{
7712 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_formControlStateOfPreviousHistoryItemBody>(*lexicalGlobalObject, *callFrame, "formControlStateOfPreviousHistoryItem");
7713}
7714
7715static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setFormControlStateOfPreviousHistoryItemBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7716{
7717 auto& vm = JSC::getVM(lexicalGlobalObject);
7718 auto throwScope = DECLARE_THROW_SCOPE(vm);
7719 UNUSED_PARAM(throwScope);
7720 UNUSED_PARAM(callFrame);
7721 auto& impl = castedThis->wrapped();
7722 if (UNLIKELY(callFrame->argumentCount() < 1))
7723 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7724 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7725 auto values = convert<IDLSequence<IDLDOMString>>(*lexicalGlobalObject, argument0.value());
7726 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7727 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setFormControlStateOfPreviousHistoryItem(WTFMove(values)); })));
7728}
7729
7730JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setFormControlStateOfPreviousHistoryItem, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7731{
7732 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setFormControlStateOfPreviousHistoryItemBody>(*lexicalGlobalObject, *callFrame, "setFormControlStateOfPreviousHistoryItem");
7733}
7734
7735static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_absoluteLineRectFromPointBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7736{
7737 auto& vm = JSC::getVM(lexicalGlobalObject);
7738 auto throwScope = DECLARE_THROW_SCOPE(vm);
7739 UNUSED_PARAM(throwScope);
7740 UNUSED_PARAM(callFrame);
7741 auto& impl = castedThis->wrapped();
7742 if (UNLIKELY(callFrame->argumentCount() < 2))
7743 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7744 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7745 auto x = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
7746 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7747 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
7748 auto y = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
7749 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7750 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<DOMRect>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.absoluteLineRectFromPoint(WTFMove(x), WTFMove(y)))));
7751}
7752
7753JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_absoluteLineRectFromPoint, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7754{
7755 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_absoluteLineRectFromPointBody>(*lexicalGlobalObject, *callFrame, "absoluteLineRectFromPoint");
7756}
7757
7758static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_absoluteCaretBoundsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7759{
7760 auto& vm = JSC::getVM(lexicalGlobalObject);
7761 auto throwScope = DECLARE_THROW_SCOPE(vm);
7762 UNUSED_PARAM(throwScope);
7763 UNUSED_PARAM(callFrame);
7764 auto& impl = castedThis->wrapped();
7765 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<DOMRect>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.absoluteCaretBounds())));
7766}
7767
7768JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_absoluteCaretBounds, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7769{
7770 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_absoluteCaretBoundsBody>(*lexicalGlobalObject, *callFrame, "absoluteCaretBounds");
7771}
7772
7773static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isCaretBlinkingSuspendedBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7774{
7775 auto& vm = JSC::getVM(lexicalGlobalObject);
7776 auto throwScope = DECLARE_THROW_SCOPE(vm);
7777 UNUSED_PARAM(throwScope);
7778 UNUSED_PARAM(callFrame);
7779 auto& impl = castedThis->wrapped();
7780 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isCaretBlinkingSuspended())));
7781}
7782
7783JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isCaretBlinkingSuspended, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7784{
7785 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isCaretBlinkingSuspendedBody>(*lexicalGlobalObject, *callFrame, "isCaretBlinkingSuspended");
7786}
7787
7788static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_boundingBoxBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7789{
7790 auto& vm = JSC::getVM(lexicalGlobalObject);
7791 auto throwScope = DECLARE_THROW_SCOPE(vm);
7792 UNUSED_PARAM(throwScope);
7793 UNUSED_PARAM(callFrame);
7794 auto& impl = castedThis->wrapped();
7795 if (UNLIKELY(callFrame->argumentCount() < 1))
7796 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7797 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7798 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "boundingBox", "Element"); });
7799 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7800 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<DOMRect>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.boundingBox(*element))));
7801}
7802
7803JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_boundingBox, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7804{
7805 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_boundingBoxBody>(*lexicalGlobalObject, *callFrame, "boundingBox");
7806}
7807
7808static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_inspectorGridOverlayCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7809{
7810 auto& vm = JSC::getVM(lexicalGlobalObject);
7811 auto throwScope = DECLARE_THROW_SCOPE(vm);
7812 UNUSED_PARAM(throwScope);
7813 UNUSED_PARAM(callFrame);
7814 auto& impl = castedThis->wrapped();
7815 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.inspectorGridOverlayCount())));
7816}
7817
7818JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_inspectorGridOverlayCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7819{
7820 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_inspectorGridOverlayCountBody>(*lexicalGlobalObject, *callFrame, "inspectorGridOverlayCount");
7821}
7822
7823static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_inspectorHighlightRectsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7824{
7825 auto& vm = JSC::getVM(lexicalGlobalObject);
7826 auto throwScope = DECLARE_THROW_SCOPE(vm);
7827 UNUSED_PARAM(throwScope);
7828 UNUSED_PARAM(callFrame);
7829 auto& impl = castedThis->wrapped();
7830 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<DOMRectList>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.inspectorHighlightRects())));
7831}
7832
7833JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_inspectorHighlightRects, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7834{
7835 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_inspectorHighlightRectsBody>(*lexicalGlobalObject, *callFrame, "inspectorHighlightRects");
7836}
7837
7838static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_markerCountForNodeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7839{
7840 auto& vm = JSC::getVM(lexicalGlobalObject);
7841 auto throwScope = DECLARE_THROW_SCOPE(vm);
7842 UNUSED_PARAM(throwScope);
7843 UNUSED_PARAM(callFrame);
7844 auto& impl = castedThis->wrapped();
7845 if (UNLIKELY(callFrame->argumentCount() < 2))
7846 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7847 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7848 auto node = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "node", "Internals", "markerCountForNode", "Node"); });
7849 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7850 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
7851 auto markerType = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
7852 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7853 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.markerCountForNode(*node, WTFMove(markerType)))));
7854}
7855
7856JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_markerCountForNode, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7857{
7858 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_markerCountForNodeBody>(*lexicalGlobalObject, *callFrame, "markerCountForNode");
7859}
7860
7861static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_markerRangeForNodeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7862{
7863 auto& vm = JSC::getVM(lexicalGlobalObject);
7864 auto throwScope = DECLARE_THROW_SCOPE(vm);
7865 UNUSED_PARAM(throwScope);
7866 UNUSED_PARAM(callFrame);
7867 auto& impl = castedThis->wrapped();
7868 if (UNLIKELY(callFrame->argumentCount() < 3))
7869 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7870 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7871 auto node = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "node", "Internals", "markerRangeForNode", "Node"); });
7872 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7873 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
7874 auto markerType = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
7875 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7876 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
7877 auto index = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument2.value());
7878 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7879 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLInterface<Range>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.markerRangeForNode(*node, WTFMove(markerType), WTFMove(index)))));
7880}
7881
7882JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_markerRangeForNode, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7883{
7884 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_markerRangeForNodeBody>(*lexicalGlobalObject, *callFrame, "markerRangeForNode");
7885}
7886
7887static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_markerDescriptionForNodeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7888{
7889 auto& vm = JSC::getVM(lexicalGlobalObject);
7890 auto throwScope = DECLARE_THROW_SCOPE(vm);
7891 UNUSED_PARAM(throwScope);
7892 UNUSED_PARAM(callFrame);
7893 auto& impl = castedThis->wrapped();
7894 if (UNLIKELY(callFrame->argumentCount() < 3))
7895 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7896 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7897 auto node = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "node", "Internals", "markerDescriptionForNode", "Node"); });
7898 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7899 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
7900 auto markerType = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
7901 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7902 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
7903 auto index = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument2.value());
7904 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7905 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.markerDescriptionForNode(*node, WTFMove(markerType), WTFMove(index)))));
7906}
7907
7908JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_markerDescriptionForNode, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7909{
7910 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_markerDescriptionForNodeBody>(*lexicalGlobalObject, *callFrame, "markerDescriptionForNode");
7911}
7912
7913static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_dumpMarkerRectsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7914{
7915 auto& vm = JSC::getVM(lexicalGlobalObject);
7916 auto throwScope = DECLARE_THROW_SCOPE(vm);
7917 UNUSED_PARAM(throwScope);
7918 UNUSED_PARAM(callFrame);
7919 auto& impl = castedThis->wrapped();
7920 if (UNLIKELY(callFrame->argumentCount() < 1))
7921 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7922 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7923 auto markerType = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
7924 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7925 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.dumpMarkerRects(WTFMove(markerType)))));
7926}
7927
7928JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_dumpMarkerRects, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7929{
7930 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_dumpMarkerRectsBody>(*lexicalGlobalObject, *callFrame, "dumpMarkerRects");
7931}
7932
7933static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMarkedTextMatchesAreHighlightedBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7934{
7935 auto& vm = JSC::getVM(lexicalGlobalObject);
7936 auto throwScope = DECLARE_THROW_SCOPE(vm);
7937 UNUSED_PARAM(throwScope);
7938 UNUSED_PARAM(callFrame);
7939 auto& impl = castedThis->wrapped();
7940 if (UNLIKELY(callFrame->argumentCount() < 1))
7941 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7942 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7943 auto flag = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
7944 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7945 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMarkedTextMatchesAreHighlighted(WTFMove(flag)); })));
7946}
7947
7948JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMarkedTextMatchesAreHighlighted, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7949{
7950 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMarkedTextMatchesAreHighlightedBody>(*lexicalGlobalObject, *callFrame, "setMarkedTextMatchesAreHighlighted");
7951}
7952
7953static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_invalidateFontCacheBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7954{
7955 auto& vm = JSC::getVM(lexicalGlobalObject);
7956 auto throwScope = DECLARE_THROW_SCOPE(vm);
7957 UNUSED_PARAM(throwScope);
7958 UNUSED_PARAM(callFrame);
7959 auto& impl = castedThis->wrapped();
7960 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.invalidateFontCache(); })));
7961}
7962
7963JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_invalidateFontCache, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7964{
7965 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_invalidateFontCacheBody>(*lexicalGlobalObject, *callFrame, "invalidateFontCache");
7966}
7967
7968static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setFontSmoothingEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7969{
7970 auto& vm = JSC::getVM(lexicalGlobalObject);
7971 auto throwScope = DECLARE_THROW_SCOPE(vm);
7972 UNUSED_PARAM(throwScope);
7973 UNUSED_PARAM(callFrame);
7974 auto& impl = castedThis->wrapped();
7975 if (UNLIKELY(callFrame->argumentCount() < 1))
7976 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7977 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7978 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
7979 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7980 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setFontSmoothingEnabled(WTFMove(enabled)); })));
7981}
7982
7983JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setFontSmoothingEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
7984{
7985 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setFontSmoothingEnabledBody>(*lexicalGlobalObject, *callFrame, "setFontSmoothingEnabled");
7986}
7987
7988static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setScrollViewPositionBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
7989{
7990 auto& vm = JSC::getVM(lexicalGlobalObject);
7991 auto throwScope = DECLARE_THROW_SCOPE(vm);
7992 UNUSED_PARAM(throwScope);
7993 UNUSED_PARAM(callFrame);
7994 auto& impl = castedThis->wrapped();
7995 if (UNLIKELY(callFrame->argumentCount() < 2))
7996 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
7997 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
7998 auto x = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
7999 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8000 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8001 auto y = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
8002 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8003 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setScrollViewPosition(WTFMove(x), WTFMove(y)); })));
8004}
8005
8006JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setScrollViewPosition, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8007{
8008 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setScrollViewPositionBody>(*lexicalGlobalObject, *callFrame, "setScrollViewPosition");
8009}
8010
8011static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_unconstrainedScrollToBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8012{
8013 auto& vm = JSC::getVM(lexicalGlobalObject);
8014 auto throwScope = DECLARE_THROW_SCOPE(vm);
8015 UNUSED_PARAM(throwScope);
8016 UNUSED_PARAM(callFrame);
8017 auto& impl = castedThis->wrapped();
8018 if (UNLIKELY(callFrame->argumentCount() < 3))
8019 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8020 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8021 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "unconstrainedScrollTo", "Element"); });
8022 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8023 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8024 auto x = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
8025 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8026 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
8027 auto y = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
8028 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8029 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.unconstrainedScrollTo(*element, WTFMove(x), WTFMove(y)); })));
8030}
8031
8032JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_unconstrainedScrollTo, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8033{
8034 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_unconstrainedScrollToBody>(*lexicalGlobalObject, *callFrame, "unconstrainedScrollTo");
8035}
8036
8037static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_scrollBySimulatingWheelEventBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8038{
8039 auto& vm = JSC::getVM(lexicalGlobalObject);
8040 auto throwScope = DECLARE_THROW_SCOPE(vm);
8041 UNUSED_PARAM(throwScope);
8042 UNUSED_PARAM(callFrame);
8043 auto& impl = castedThis->wrapped();
8044 if (UNLIKELY(callFrame->argumentCount() < 3))
8045 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8046 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8047 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "scrollBySimulatingWheelEvent", "Element"); });
8048 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8049 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8050 auto deltaX = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
8051 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8052 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
8053 auto deltaY = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
8054 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8055 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.scrollBySimulatingWheelEvent(*element, WTFMove(deltaX), WTFMove(deltaY)); })));
8056}
8057
8058JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_scrollBySimulatingWheelEvent, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8059{
8060 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_scrollBySimulatingWheelEventBody>(*lexicalGlobalObject, *callFrame, "scrollBySimulatingWheelEvent");
8061}
8062
8063static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_layoutViewportRectBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8064{
8065 auto& vm = JSC::getVM(lexicalGlobalObject);
8066 auto throwScope = DECLARE_THROW_SCOPE(vm);
8067 UNUSED_PARAM(throwScope);
8068 UNUSED_PARAM(callFrame);
8069 auto& impl = castedThis->wrapped();
8070 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<DOMRect>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.layoutViewportRect())));
8071}
8072
8073JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_layoutViewportRect, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8074{
8075 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_layoutViewportRectBody>(*lexicalGlobalObject, *callFrame, "layoutViewportRect");
8076}
8077
8078static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_visualViewportRectBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8079{
8080 auto& vm = JSC::getVM(lexicalGlobalObject);
8081 auto throwScope = DECLARE_THROW_SCOPE(vm);
8082 UNUSED_PARAM(throwScope);
8083 UNUSED_PARAM(callFrame);
8084 auto& impl = castedThis->wrapped();
8085 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<DOMRect>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.visualViewportRect())));
8086}
8087
8088JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_visualViewportRect, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8089{
8090 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_visualViewportRectBody>(*lexicalGlobalObject, *callFrame, "visualViewportRect");
8091}
8092
8093static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setViewIsTransparentBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8094{
8095 auto& vm = JSC::getVM(lexicalGlobalObject);
8096 auto throwScope = DECLARE_THROW_SCOPE(vm);
8097 UNUSED_PARAM(throwScope);
8098 UNUSED_PARAM(callFrame);
8099 auto& impl = castedThis->wrapped();
8100 if (UNLIKELY(callFrame->argumentCount() < 1))
8101 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8102 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8103 auto trnasparent = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
8104 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8105 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setViewIsTransparent(WTFMove(trnasparent)); })));
8106}
8107
8108JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setViewIsTransparent, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8109{
8110 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setViewIsTransparentBody>(*lexicalGlobalObject, *callFrame, "setViewIsTransparent");
8111}
8112
8113static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_viewBaseBackgroundColorBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8114{
8115 auto& vm = JSC::getVM(lexicalGlobalObject);
8116 auto throwScope = DECLARE_THROW_SCOPE(vm);
8117 UNUSED_PARAM(throwScope);
8118 UNUSED_PARAM(callFrame);
8119 auto& impl = castedThis->wrapped();
8120 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.viewBaseBackgroundColor())));
8121}
8122
8123JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_viewBaseBackgroundColor, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8124{
8125 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_viewBaseBackgroundColorBody>(*lexicalGlobalObject, *callFrame, "viewBaseBackgroundColor");
8126}
8127
8128static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setViewBaseBackgroundColorBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8129{
8130 auto& vm = JSC::getVM(lexicalGlobalObject);
8131 auto throwScope = DECLARE_THROW_SCOPE(vm);
8132 UNUSED_PARAM(throwScope);
8133 UNUSED_PARAM(callFrame);
8134 auto& impl = castedThis->wrapped();
8135 if (UNLIKELY(callFrame->argumentCount() < 1))
8136 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8137 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8138 auto colorValue = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
8139 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8140 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setViewBaseBackgroundColor(WTFMove(colorValue)); })));
8141}
8142
8143JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setViewBaseBackgroundColor, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8144{
8145 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setViewBaseBackgroundColorBody>(*lexicalGlobalObject, *callFrame, "setViewBaseBackgroundColor");
8146}
8147
8148static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setPaginationBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8149{
8150 auto& vm = JSC::getVM(lexicalGlobalObject);
8151 auto throwScope = DECLARE_THROW_SCOPE(vm);
8152 UNUSED_PARAM(throwScope);
8153 UNUSED_PARAM(callFrame);
8154 auto& impl = castedThis->wrapped();
8155 if (UNLIKELY(callFrame->argumentCount() < 2))
8156 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8157 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8158 auto mode = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
8159 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8160 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8161 auto gap = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
8162 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8163 EnsureStillAliveScope argument2 = callFrame->argument(2);
8164 auto pageLength = convert<IDLLong>(*lexicalGlobalObject, argument2.value());
8165 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8166 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setPagination(WTFMove(mode), WTFMove(gap), WTFMove(pageLength)); })));
8167}
8168
8169JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPagination, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8170{
8171 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setPaginationBody>(*lexicalGlobalObject, *callFrame, "setPagination");
8172}
8173
8174static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setPaginationLineGridEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8175{
8176 auto& vm = JSC::getVM(lexicalGlobalObject);
8177 auto throwScope = DECLARE_THROW_SCOPE(vm);
8178 UNUSED_PARAM(throwScope);
8179 UNUSED_PARAM(callFrame);
8180 auto& impl = castedThis->wrapped();
8181 if (UNLIKELY(callFrame->argumentCount() < 1))
8182 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8183 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8184 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
8185 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8186 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setPaginationLineGridEnabled(WTFMove(enabled)); })));
8187}
8188
8189JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPaginationLineGridEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8190{
8191 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setPaginationLineGridEnabledBody>(*lexicalGlobalObject, *callFrame, "setPaginationLineGridEnabled");
8192}
8193
8194static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_configurationForViewportBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8195{
8196 auto& vm = JSC::getVM(lexicalGlobalObject);
8197 auto throwScope = DECLARE_THROW_SCOPE(vm);
8198 UNUSED_PARAM(throwScope);
8199 UNUSED_PARAM(callFrame);
8200 auto& impl = castedThis->wrapped();
8201 if (UNLIKELY(callFrame->argumentCount() < 5))
8202 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8203 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8204 auto devicePixelRatio = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument0.value());
8205 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8206 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8207 auto deviceWidth = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
8208 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8209 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
8210 auto deviceHeight = convert<IDLLong>(*lexicalGlobalObject, argument2.value());
8211 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8212 EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
8213 auto availableWidth = convert<IDLLong>(*lexicalGlobalObject, argument3.value());
8214 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8215 EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
8216 auto availableHeight = convert<IDLLong>(*lexicalGlobalObject, argument4.value());
8217 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8218 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.configurationForViewport(WTFMove(devicePixelRatio), WTFMove(deviceWidth), WTFMove(deviceHeight), WTFMove(availableWidth), WTFMove(availableHeight)))));
8219}
8220
8221JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_configurationForViewport, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8222{
8223 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_configurationForViewportBody>(*lexicalGlobalObject, *callFrame, "configurationForViewport");
8224}
8225
8226static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_wasLastChangeUserEditBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8227{
8228 auto& vm = JSC::getVM(lexicalGlobalObject);
8229 auto throwScope = DECLARE_THROW_SCOPE(vm);
8230 UNUSED_PARAM(throwScope);
8231 UNUSED_PARAM(callFrame);
8232 auto& impl = castedThis->wrapped();
8233 if (UNLIKELY(callFrame->argumentCount() < 1))
8234 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8235 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8236 auto textField = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "textField", "Internals", "wasLastChangeUserEdit", "Element"); });
8237 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8238 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.wasLastChangeUserEdit(*textField))));
8239}
8240
8241JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_wasLastChangeUserEdit, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8242{
8243 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_wasLastChangeUserEditBody>(*lexicalGlobalObject, *callFrame, "wasLastChangeUserEdit");
8244}
8245
8246static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_elementShouldAutoCompleteBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8247{
8248 auto& vm = JSC::getVM(lexicalGlobalObject);
8249 auto throwScope = DECLARE_THROW_SCOPE(vm);
8250 UNUSED_PARAM(throwScope);
8251 UNUSED_PARAM(callFrame);
8252 auto& impl = castedThis->wrapped();
8253 if (UNLIKELY(callFrame->argumentCount() < 1))
8254 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8255 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8256 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "inputElement", "Internals", "elementShouldAutoComplete", "HTMLInputElement"); });
8257 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8258 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.elementShouldAutoComplete(*inputElement))));
8259}
8260
8261JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_elementShouldAutoComplete, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8262{
8263 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_elementShouldAutoCompleteBody>(*lexicalGlobalObject, *callFrame, "elementShouldAutoComplete");
8264}
8265
8266static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setAutofilledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8267{
8268 auto& vm = JSC::getVM(lexicalGlobalObject);
8269 auto throwScope = DECLARE_THROW_SCOPE(vm);
8270 UNUSED_PARAM(throwScope);
8271 UNUSED_PARAM(callFrame);
8272 auto& impl = castedThis->wrapped();
8273 if (UNLIKELY(callFrame->argumentCount() < 2))
8274 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8275 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8276 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "inputElement", "Internals", "setAutofilled", "HTMLInputElement"); });
8277 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8278 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8279 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
8280 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8281 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setAutofilled(*inputElement, WTFMove(enabled)); })));
8282}
8283
8284JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAutofilled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8285{
8286 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setAutofilledBody>(*lexicalGlobalObject, *callFrame, "setAutofilled");
8287}
8288
8289static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setAutoFilledAndViewableBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8290{
8291 auto& vm = JSC::getVM(lexicalGlobalObject);
8292 auto throwScope = DECLARE_THROW_SCOPE(vm);
8293 UNUSED_PARAM(throwScope);
8294 UNUSED_PARAM(callFrame);
8295 auto& impl = castedThis->wrapped();
8296 if (UNLIKELY(callFrame->argumentCount() < 2))
8297 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8298 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8299 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "inputElement", "Internals", "setAutoFilledAndViewable", "HTMLInputElement"); });
8300 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8301 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8302 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
8303 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8304 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setAutoFilledAndViewable(*inputElement, WTFMove(enabled)); })));
8305}
8306
8307JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAutoFilledAndViewable, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8308{
8309 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setAutoFilledAndViewableBody>(*lexicalGlobalObject, *callFrame, "setAutoFilledAndViewable");
8310}
8311
8312static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setShowAutoFillButtonBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8313{
8314 auto& vm = JSC::getVM(lexicalGlobalObject);
8315 auto throwScope = DECLARE_THROW_SCOPE(vm);
8316 UNUSED_PARAM(throwScope);
8317 UNUSED_PARAM(callFrame);
8318 auto& impl = castedThis->wrapped();
8319 if (UNLIKELY(callFrame->argumentCount() < 2))
8320 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8321 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8322 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "inputElement", "Internals", "setShowAutoFillButton", "HTMLInputElement"); });
8323 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8324 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8325 auto autoFillButtonType = convert<IDLEnumeration<Internals::AutoFillButtonType>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 1, "autoFillButtonType", "Internals", "setShowAutoFillButton", expectedEnumerationValues<Internals::AutoFillButtonType>()); });
8326 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8327 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setShowAutoFillButton(*inputElement, WTFMove(autoFillButtonType)); })));
8328}
8329
8330JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setShowAutoFillButton, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8331{
8332 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setShowAutoFillButtonBody>(*lexicalGlobalObject, *callFrame, "setShowAutoFillButton");
8333}
8334
8335static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_autoFillButtonTypeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8336{
8337 auto& vm = JSC::getVM(lexicalGlobalObject);
8338 auto throwScope = DECLARE_THROW_SCOPE(vm);
8339 UNUSED_PARAM(throwScope);
8340 UNUSED_PARAM(callFrame);
8341 auto& impl = castedThis->wrapped();
8342 if (UNLIKELY(callFrame->argumentCount() < 1))
8343 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8344 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8345 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "inputElement", "Internals", "autoFillButtonType", "HTMLInputElement"); });
8346 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8347 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLEnumeration<Internals::AutoFillButtonType>>(*lexicalGlobalObject, throwScope, impl.autoFillButtonType(*inputElement))));
8348}
8349
8350JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_autoFillButtonType, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8351{
8352 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_autoFillButtonTypeBody>(*lexicalGlobalObject, *callFrame, "autoFillButtonType");
8353}
8354
8355static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_lastAutoFillButtonTypeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8356{
8357 auto& vm = JSC::getVM(lexicalGlobalObject);
8358 auto throwScope = DECLARE_THROW_SCOPE(vm);
8359 UNUSED_PARAM(throwScope);
8360 UNUSED_PARAM(callFrame);
8361 auto& impl = castedThis->wrapped();
8362 if (UNLIKELY(callFrame->argumentCount() < 1))
8363 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8364 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8365 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "inputElement", "Internals", "lastAutoFillButtonType", "HTMLInputElement"); });
8366 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8367 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLEnumeration<Internals::AutoFillButtonType>>(*lexicalGlobalObject, throwScope, impl.lastAutoFillButtonType(*inputElement))));
8368}
8369
8370JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_lastAutoFillButtonType, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8371{
8372 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_lastAutoFillButtonTypeBody>(*lexicalGlobalObject, *callFrame, "lastAutoFillButtonType");
8373}
8374
8375static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setCanShowPlaceholderBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8376{
8377 auto& vm = JSC::getVM(lexicalGlobalObject);
8378 auto throwScope = DECLARE_THROW_SCOPE(vm);
8379 UNUSED_PARAM(throwScope);
8380 UNUSED_PARAM(callFrame);
8381 auto& impl = castedThis->wrapped();
8382 if (UNLIKELY(callFrame->argumentCount() < 2))
8383 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8384 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8385 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "setCanShowPlaceholder", "Element"); });
8386 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8387 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8388 auto canShowPlaceholder = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
8389 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8390 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setCanShowPlaceholder(*element, WTFMove(canShowPlaceholder)); })));
8391}
8392
8393JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setCanShowPlaceholder, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8394{
8395 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setCanShowPlaceholderBody>(*lexicalGlobalObject, *callFrame, "setCanShowPlaceholder");
8396}
8397
8398static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_insertTextPlaceholderBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8399{
8400 auto& vm = JSC::getVM(lexicalGlobalObject);
8401 auto throwScope = DECLARE_THROW_SCOPE(vm);
8402 UNUSED_PARAM(throwScope);
8403 UNUSED_PARAM(callFrame);
8404 auto& impl = castedThis->wrapped();
8405 if (UNLIKELY(callFrame->argumentCount() < 2))
8406 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8407 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8408 auto width = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
8409 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8410 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8411 auto height = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
8412 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8413 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<Element>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.insertTextPlaceholder(WTFMove(width), WTFMove(height)))));
8414}
8415
8416JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_insertTextPlaceholder, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8417{
8418 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_insertTextPlaceholderBody>(*lexicalGlobalObject, *callFrame, "insertTextPlaceholder");
8419}
8420
8421static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_removeTextPlaceholderBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8422{
8423 auto& vm = JSC::getVM(lexicalGlobalObject);
8424 auto throwScope = DECLARE_THROW_SCOPE(vm);
8425 UNUSED_PARAM(throwScope);
8426 UNUSED_PARAM(callFrame);
8427 auto& impl = castedThis->wrapped();
8428 if (UNLIKELY(callFrame->argumentCount() < 1))
8429 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8430 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8431 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "removeTextPlaceholder", "Element"); });
8432 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8433 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.removeTextPlaceholder(*element); })));
8434}
8435
8436JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_removeTextPlaceholder, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8437{
8438 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_removeTextPlaceholderBody>(*lexicalGlobalObject, *callFrame, "removeTextPlaceholder");
8439}
8440
8441static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_rangeOfStringBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8442{
8443 auto& vm = JSC::getVM(lexicalGlobalObject);
8444 auto throwScope = DECLARE_THROW_SCOPE(vm);
8445 UNUSED_PARAM(throwScope);
8446 UNUSED_PARAM(callFrame);
8447 auto& impl = castedThis->wrapped();
8448 if (UNLIKELY(callFrame->argumentCount() < 3))
8449 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8450 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8451 auto text = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
8452 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8453 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8454 auto referenceRange = convert<IDLNullable<IDLInterface<Range>>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "referenceRange", "Internals", "rangeOfString", "Range"); });
8455 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8456 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
8457 auto findOptions = convert<IDLSequence<IDLDOMString>>(*lexicalGlobalObject, argument2.value());
8458 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8459 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLInterface<Range>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.rangeOfString(WTFMove(text), WTFMove(referenceRange), WTFMove(findOptions)))));
8460}
8461
8462JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeOfString, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8463{
8464 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_rangeOfStringBody>(*lexicalGlobalObject, *callFrame, "rangeOfString");
8465}
8466
8467static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_countMatchesForTextBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8468{
8469 auto& vm = JSC::getVM(lexicalGlobalObject);
8470 auto throwScope = DECLARE_THROW_SCOPE(vm);
8471 UNUSED_PARAM(throwScope);
8472 UNUSED_PARAM(callFrame);
8473 auto& impl = castedThis->wrapped();
8474 if (UNLIKELY(callFrame->argumentCount() < 3))
8475 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8476 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8477 auto text = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
8478 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8479 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8480 auto findOptions = convert<IDLSequence<IDLDOMString>>(*lexicalGlobalObject, argument1.value());
8481 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8482 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
8483 auto markMatches = convert<IDLDOMString>(*lexicalGlobalObject, argument2.value());
8484 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8485 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.countMatchesForText(WTFMove(text), WTFMove(findOptions), WTFMove(markMatches)))));
8486}
8487
8488JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_countMatchesForText, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8489{
8490 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_countMatchesForTextBody>(*lexicalGlobalObject, *callFrame, "countMatchesForText");
8491}
8492
8493static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_countFindMatchesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8494{
8495 auto& vm = JSC::getVM(lexicalGlobalObject);
8496 auto throwScope = DECLARE_THROW_SCOPE(vm);
8497 UNUSED_PARAM(throwScope);
8498 UNUSED_PARAM(callFrame);
8499 auto& impl = castedThis->wrapped();
8500 if (UNLIKELY(callFrame->argumentCount() < 2))
8501 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8502 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8503 auto text = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
8504 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8505 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8506 auto findOptions = convert<IDLSequence<IDLDOMString>>(*lexicalGlobalObject, argument1.value());
8507 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8508 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.countFindMatches(WTFMove(text), WTFMove(findOptions)))));
8509}
8510
8511JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_countFindMatches, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8512{
8513 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_countFindMatchesBody>(*lexicalGlobalObject, *callFrame, "countFindMatches");
8514}
8515
8516static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_autofillFieldNameBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8517{
8518 auto& vm = JSC::getVM(lexicalGlobalObject);
8519 auto throwScope = DECLARE_THROW_SCOPE(vm);
8520 UNUSED_PARAM(throwScope);
8521 UNUSED_PARAM(callFrame);
8522 auto& impl = castedThis->wrapped();
8523 if (UNLIKELY(callFrame->argumentCount() < 1))
8524 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8525 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8526 auto formControlElement = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "formControlElement", "Internals", "autofillFieldName", "Element"); });
8527 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8528 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.autofillFieldName(*formControlElement))));
8529}
8530
8531JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_autofillFieldName, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8532{
8533 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_autofillFieldNameBody>(*lexicalGlobalObject, *callFrame, "autofillFieldName");
8534}
8535
8536static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isSpellcheckDisabledExceptTextReplacementBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8537{
8538 auto& vm = JSC::getVM(lexicalGlobalObject);
8539 auto throwScope = DECLARE_THROW_SCOPE(vm);
8540 UNUSED_PARAM(throwScope);
8541 UNUSED_PARAM(callFrame);
8542 auto& impl = castedThis->wrapped();
8543 if (UNLIKELY(callFrame->argumentCount() < 1))
8544 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8545 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8546 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "inputElement", "Internals", "isSpellcheckDisabledExceptTextReplacement", "HTMLInputElement"); });
8547 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8548 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isSpellcheckDisabledExceptTextReplacement(*inputElement))));
8549}
8550
8551JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isSpellcheckDisabledExceptTextReplacement, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8552{
8553 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isSpellcheckDisabledExceptTextReplacementBody>(*lexicalGlobalObject, *callFrame, "isSpellcheckDisabledExceptTextReplacement");
8554}
8555
8556static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_invalidateControlTintsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8557{
8558 auto& vm = JSC::getVM(lexicalGlobalObject);
8559 auto throwScope = DECLARE_THROW_SCOPE(vm);
8560 UNUSED_PARAM(throwScope);
8561 UNUSED_PARAM(callFrame);
8562 auto& impl = castedThis->wrapped();
8563 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.invalidateControlTints(); })));
8564}
8565
8566JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_invalidateControlTints, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8567{
8568 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_invalidateControlTintsBody>(*lexicalGlobalObject, *callFrame, "invalidateControlTints");
8569}
8570
8571static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_scrollElementToRectBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8572{
8573 auto& vm = JSC::getVM(lexicalGlobalObject);
8574 auto throwScope = DECLARE_THROW_SCOPE(vm);
8575 UNUSED_PARAM(throwScope);
8576 UNUSED_PARAM(callFrame);
8577 auto& impl = castedThis->wrapped();
8578 if (UNLIKELY(callFrame->argumentCount() < 5))
8579 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8580 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8581 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "scrollElementToRect", "Element"); });
8582 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8583 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8584 auto x = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
8585 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8586 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
8587 auto y = convert<IDLLong>(*lexicalGlobalObject, argument2.value());
8588 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8589 EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
8590 auto w = convert<IDLLong>(*lexicalGlobalObject, argument3.value());
8591 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8592 EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
8593 auto h = convert<IDLLong>(*lexicalGlobalObject, argument4.value());
8594 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8595 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.scrollElementToRect(*element, WTFMove(x), WTFMove(y), WTFMove(w), WTFMove(h)); })));
8596}
8597
8598JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_scrollElementToRect, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8599{
8600 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_scrollElementToRectBody>(*lexicalGlobalObject, *callFrame, "scrollElementToRect");
8601}
8602
8603static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_rangeFromLocationAndLengthBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8604{
8605 auto& vm = JSC::getVM(lexicalGlobalObject);
8606 auto throwScope = DECLARE_THROW_SCOPE(vm);
8607 UNUSED_PARAM(throwScope);
8608 UNUSED_PARAM(callFrame);
8609 auto& impl = castedThis->wrapped();
8610 if (UNLIKELY(callFrame->argumentCount() < 3))
8611 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8612 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8613 auto scope = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "scope", "Internals", "rangeFromLocationAndLength", "Element"); });
8614 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8615 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8616 auto rangeLocation = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument1.value());
8617 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8618 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
8619 auto rangeLength = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument2.value());
8620 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8621 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLInterface<Range>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.rangeFromLocationAndLength(*scope, WTFMove(rangeLocation), WTFMove(rangeLength)))));
8622}
8623
8624JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeFromLocationAndLength, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8625{
8626 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_rangeFromLocationAndLengthBody>(*lexicalGlobalObject, *callFrame, "rangeFromLocationAndLength");
8627}
8628
8629static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_locationFromRangeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8630{
8631 auto& vm = JSC::getVM(lexicalGlobalObject);
8632 auto throwScope = DECLARE_THROW_SCOPE(vm);
8633 UNUSED_PARAM(throwScope);
8634 UNUSED_PARAM(callFrame);
8635 auto& impl = castedThis->wrapped();
8636 if (UNLIKELY(callFrame->argumentCount() < 2))
8637 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8638 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8639 auto scope = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "scope", "Internals", "locationFromRange", "Element"); });
8640 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8641 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8642 auto range = convert<IDLInterface<Range>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "range", "Internals", "locationFromRange", "Range"); });
8643 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8644 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.locationFromRange(*scope, *range))));
8645}
8646
8647JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_locationFromRange, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8648{
8649 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_locationFromRangeBody>(*lexicalGlobalObject, *callFrame, "locationFromRange");
8650}
8651
8652static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_lengthFromRangeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8653{
8654 auto& vm = JSC::getVM(lexicalGlobalObject);
8655 auto throwScope = DECLARE_THROW_SCOPE(vm);
8656 UNUSED_PARAM(throwScope);
8657 UNUSED_PARAM(callFrame);
8658 auto& impl = castedThis->wrapped();
8659 if (UNLIKELY(callFrame->argumentCount() < 2))
8660 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8661 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8662 auto scope = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "scope", "Internals", "lengthFromRange", "Element"); });
8663 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8664 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8665 auto range = convert<IDLInterface<Range>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "range", "Internals", "lengthFromRange", "Range"); });
8666 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8667 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.lengthFromRange(*scope, *range))));
8668}
8669
8670JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_lengthFromRange, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8671{
8672 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_lengthFromRangeBody>(*lexicalGlobalObject, *callFrame, "lengthFromRange");
8673}
8674
8675static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_rangeAsTextBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8676{
8677 auto& vm = JSC::getVM(lexicalGlobalObject);
8678 auto throwScope = DECLARE_THROW_SCOPE(vm);
8679 UNUSED_PARAM(throwScope);
8680 UNUSED_PARAM(callFrame);
8681 auto& impl = castedThis->wrapped();
8682 if (UNLIKELY(callFrame->argumentCount() < 1))
8683 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8684 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8685 auto range = convert<IDLInterface<Range>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "range", "Internals", "rangeAsText", "Range"); });
8686 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8687 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.rangeAsText(*range))));
8688}
8689
8690JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeAsText, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8691{
8692 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_rangeAsTextBody>(*lexicalGlobalObject, *callFrame, "rangeAsText");
8693}
8694
8695static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_rangeAsTextUsingBackwardsTextIteratorBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8696{
8697 auto& vm = JSC::getVM(lexicalGlobalObject);
8698 auto throwScope = DECLARE_THROW_SCOPE(vm);
8699 UNUSED_PARAM(throwScope);
8700 UNUSED_PARAM(callFrame);
8701 auto& impl = castedThis->wrapped();
8702 if (UNLIKELY(callFrame->argumentCount() < 1))
8703 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8704 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8705 auto range = convert<IDLInterface<Range>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "range", "Internals", "rangeAsTextUsingBackwardsTextIterator", "Range"); });
8706 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8707 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.rangeAsTextUsingBackwardsTextIterator(*range))));
8708}
8709
8710JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeAsTextUsingBackwardsTextIterator, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8711{
8712 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_rangeAsTextUsingBackwardsTextIteratorBody>(*lexicalGlobalObject, *callFrame, "rangeAsTextUsingBackwardsTextIterator");
8713}
8714
8715static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_subrangeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8716{
8717 auto& vm = JSC::getVM(lexicalGlobalObject);
8718 auto throwScope = DECLARE_THROW_SCOPE(vm);
8719 UNUSED_PARAM(throwScope);
8720 UNUSED_PARAM(callFrame);
8721 auto& impl = castedThis->wrapped();
8722 if (UNLIKELY(callFrame->argumentCount() < 3))
8723 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8724 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8725 auto range = convert<IDLInterface<Range>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "range", "Internals", "subrange", "Range"); });
8726 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8727 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8728 auto rangeLocation = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument1.value());
8729 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8730 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
8731 auto rangeLength = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument2.value());
8732 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8733 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<Range>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.subrange(*range, WTFMove(rangeLocation), WTFMove(rangeLength)))));
8734}
8735
8736JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_subrange, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8737{
8738 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_subrangeBody>(*lexicalGlobalObject, *callFrame, "subrange");
8739}
8740
8741static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_rangeForDictionaryLookupAtLocationBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8742{
8743 auto& vm = JSC::getVM(lexicalGlobalObject);
8744 auto throwScope = DECLARE_THROW_SCOPE(vm);
8745 UNUSED_PARAM(throwScope);
8746 UNUSED_PARAM(callFrame);
8747 auto& impl = castedThis->wrapped();
8748 if (UNLIKELY(callFrame->argumentCount() < 2))
8749 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8750 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8751 auto x = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
8752 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8753 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8754 auto y = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
8755 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8756 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLInterface<Range>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.rangeForDictionaryLookupAtLocation(WTFMove(x), WTFMove(y)))));
8757}
8758
8759JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeForDictionaryLookupAtLocation, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8760{
8761 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_rangeForDictionaryLookupAtLocationBody>(*lexicalGlobalObject, *callFrame, "rangeForDictionaryLookupAtLocation");
8762}
8763
8764static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_rangeOfStringNearLocationBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8765{
8766 auto& vm = JSC::getVM(lexicalGlobalObject);
8767 auto throwScope = DECLARE_THROW_SCOPE(vm);
8768 UNUSED_PARAM(throwScope);
8769 UNUSED_PARAM(callFrame);
8770 auto& impl = castedThis->wrapped();
8771 if (UNLIKELY(callFrame->argumentCount() < 3))
8772 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8773 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8774 auto range = convert<IDLInterface<Range>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "range", "Internals", "rangeOfStringNearLocation", "Range"); });
8775 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8776 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
8777 auto text = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
8778 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8779 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
8780 auto targetOffset = convert<IDLLong>(*lexicalGlobalObject, argument2.value());
8781 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8782 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLInterface<Range>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.rangeOfStringNearLocation(*range, WTFMove(text), WTFMove(targetOffset)))));
8783}
8784
8785JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeOfStringNearLocation, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8786{
8787 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_rangeOfStringNearLocationBody>(*lexicalGlobalObject, *callFrame, "rangeOfStringNearLocation");
8788}
8789
8790static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setDelegatesScrollingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8791{
8792 auto& vm = JSC::getVM(lexicalGlobalObject);
8793 auto throwScope = DECLARE_THROW_SCOPE(vm);
8794 UNUSED_PARAM(throwScope);
8795 UNUSED_PARAM(callFrame);
8796 auto& impl = castedThis->wrapped();
8797 if (UNLIKELY(callFrame->argumentCount() < 1))
8798 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8799 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8800 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
8801 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8802 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setDelegatesScrolling(WTFMove(enabled)); })));
8803}
8804
8805JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setDelegatesScrolling, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8806{
8807 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setDelegatesScrollingBody>(*lexicalGlobalObject, *callFrame, "setDelegatesScrolling");
8808}
8809
8810static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_lastSpellCheckRequestSequenceBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8811{
8812 auto& vm = JSC::getVM(lexicalGlobalObject);
8813 auto throwScope = DECLARE_THROW_SCOPE(vm);
8814 UNUSED_PARAM(throwScope);
8815 UNUSED_PARAM(callFrame);
8816 auto& impl = castedThis->wrapped();
8817 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLongLong>(*lexicalGlobalObject, throwScope, impl.lastSpellCheckRequestSequence())));
8818}
8819
8820JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_lastSpellCheckRequestSequence, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8821{
8822 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_lastSpellCheckRequestSequenceBody>(*lexicalGlobalObject, *callFrame, "lastSpellCheckRequestSequence");
8823}
8824
8825static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_lastSpellCheckProcessedSequenceBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8826{
8827 auto& vm = JSC::getVM(lexicalGlobalObject);
8828 auto throwScope = DECLARE_THROW_SCOPE(vm);
8829 UNUSED_PARAM(throwScope);
8830 UNUSED_PARAM(callFrame);
8831 auto& impl = castedThis->wrapped();
8832 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLongLong>(*lexicalGlobalObject, throwScope, impl.lastSpellCheckProcessedSequence())));
8833}
8834
8835JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_lastSpellCheckProcessedSequence, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8836{
8837 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_lastSpellCheckProcessedSequenceBody>(*lexicalGlobalObject, *callFrame, "lastSpellCheckProcessedSequence");
8838}
8839
8840static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_advanceToNextMisspellingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8841{
8842 auto& vm = JSC::getVM(lexicalGlobalObject);
8843 auto throwScope = DECLARE_THROW_SCOPE(vm);
8844 UNUSED_PARAM(throwScope);
8845 UNUSED_PARAM(callFrame);
8846 auto& impl = castedThis->wrapped();
8847 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.advanceToNextMisspelling(); })));
8848}
8849
8850JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_advanceToNextMisspelling, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8851{
8852 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_advanceToNextMisspellingBody>(*lexicalGlobalObject, *callFrame, "advanceToNextMisspelling");
8853}
8854
8855static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_userPreferredLanguagesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8856{
8857 auto& vm = JSC::getVM(lexicalGlobalObject);
8858 auto throwScope = DECLARE_THROW_SCOPE(vm);
8859 UNUSED_PARAM(throwScope);
8860 UNUSED_PARAM(callFrame);
8861 auto& impl = castedThis->wrapped();
8862 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.userPreferredLanguages())));
8863}
8864
8865JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_userPreferredLanguages, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8866{
8867 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_userPreferredLanguagesBody>(*lexicalGlobalObject, *callFrame, "userPreferredLanguages");
8868}
8869
8870static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setUserPreferredLanguagesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8871{
8872 auto& vm = JSC::getVM(lexicalGlobalObject);
8873 auto throwScope = DECLARE_THROW_SCOPE(vm);
8874 UNUSED_PARAM(throwScope);
8875 UNUSED_PARAM(callFrame);
8876 auto& impl = castedThis->wrapped();
8877 if (UNLIKELY(callFrame->argumentCount() < 1))
8878 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8879 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8880 auto languages = convert<IDLSequence<IDLDOMString>>(*lexicalGlobalObject, argument0.value());
8881 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8882 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setUserPreferredLanguages(WTFMove(languages)); })));
8883}
8884
8885JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUserPreferredLanguages, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8886{
8887 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setUserPreferredLanguagesBody>(*lexicalGlobalObject, *callFrame, "setUserPreferredLanguages");
8888}
8889
8890static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_userPreferredAudioCharacteristicsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8891{
8892 auto& vm = JSC::getVM(lexicalGlobalObject);
8893 auto throwScope = DECLARE_THROW_SCOPE(vm);
8894 UNUSED_PARAM(throwScope);
8895 UNUSED_PARAM(callFrame);
8896 auto& impl = castedThis->wrapped();
8897 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.userPreferredAudioCharacteristics())));
8898}
8899
8900JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_userPreferredAudioCharacteristics, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8901{
8902 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_userPreferredAudioCharacteristicsBody>(*lexicalGlobalObject, *callFrame, "userPreferredAudioCharacteristics");
8903}
8904
8905static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setUserPreferredAudioCharacteristicBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8906{
8907 auto& vm = JSC::getVM(lexicalGlobalObject);
8908 auto throwScope = DECLARE_THROW_SCOPE(vm);
8909 UNUSED_PARAM(throwScope);
8910 UNUSED_PARAM(callFrame);
8911 auto& impl = castedThis->wrapped();
8912 if (UNLIKELY(callFrame->argumentCount() < 1))
8913 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8914 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8915 auto characteristic = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
8916 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8917 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setUserPreferredAudioCharacteristic(WTFMove(characteristic)); })));
8918}
8919
8920JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUserPreferredAudioCharacteristic, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8921{
8922 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setUserPreferredAudioCharacteristicBody>(*lexicalGlobalObject, *callFrame, "setUserPreferredAudioCharacteristic");
8923}
8924
8925static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_wheelEventHandlerCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8926{
8927 auto& vm = JSC::getVM(lexicalGlobalObject);
8928 auto throwScope = DECLARE_THROW_SCOPE(vm);
8929 UNUSED_PARAM(throwScope);
8930 UNUSED_PARAM(callFrame);
8931 auto& impl = castedThis->wrapped();
8932 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.wheelEventHandlerCount())));
8933}
8934
8935JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_wheelEventHandlerCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8936{
8937 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_wheelEventHandlerCountBody>(*lexicalGlobalObject, *callFrame, "wheelEventHandlerCount");
8938}
8939
8940static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_touchEventHandlerCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8941{
8942 auto& vm = JSC::getVM(lexicalGlobalObject);
8943 auto throwScope = DECLARE_THROW_SCOPE(vm);
8944 UNUSED_PARAM(throwScope);
8945 UNUSED_PARAM(callFrame);
8946 auto& impl = castedThis->wrapped();
8947 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.touchEventHandlerCount())));
8948}
8949
8950JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_touchEventHandlerCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8951{
8952 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_touchEventHandlerCountBody>(*lexicalGlobalObject, *callFrame, "touchEventHandlerCount");
8953}
8954
8955static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_touchEventRectsForEventBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8956{
8957 auto& vm = JSC::getVM(lexicalGlobalObject);
8958 auto throwScope = DECLARE_THROW_SCOPE(vm);
8959 UNUSED_PARAM(throwScope);
8960 UNUSED_PARAM(callFrame);
8961 auto& impl = castedThis->wrapped();
8962 if (UNLIKELY(callFrame->argumentCount() < 1))
8963 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8964 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
8965 auto eventName = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
8966 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8967 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<DOMRectList>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.touchEventRectsForEvent(WTFMove(eventName)))));
8968}
8969
8970JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_touchEventRectsForEvent, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8971{
8972 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_touchEventRectsForEventBody>(*lexicalGlobalObject, *callFrame, "touchEventRectsForEvent");
8973}
8974
8975static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_passiveTouchEventListenerRectsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8976{
8977 auto& vm = JSC::getVM(lexicalGlobalObject);
8978 auto throwScope = DECLARE_THROW_SCOPE(vm);
8979 UNUSED_PARAM(throwScope);
8980 UNUSED_PARAM(callFrame);
8981 auto& impl = castedThis->wrapped();
8982 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<DOMRectList>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.passiveTouchEventListenerRects())));
8983}
8984
8985JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_passiveTouchEventListenerRects, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
8986{
8987 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_passiveTouchEventListenerRectsBody>(*lexicalGlobalObject, *callFrame, "passiveTouchEventListenerRects");
8988}
8989
8990static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_nodesFromRectBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
8991{
8992 auto& vm = JSC::getVM(lexicalGlobalObject);
8993 auto throwScope = DECLARE_THROW_SCOPE(vm);
8994 UNUSED_PARAM(throwScope);
8995 UNUSED_PARAM(callFrame);
8996 auto& impl = castedThis->wrapped();
8997 if (UNLIKELY(callFrame->argumentCount() < 10))
8998 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
8999 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9000 auto document = convert<IDLInterface<Document>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "document", "Internals", "nodesFromRect", "Document"); });
9001 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9002 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
9003 auto x = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
9004 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9005 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
9006 auto y = convert<IDLLong>(*lexicalGlobalObject, argument2.value());
9007 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9008 EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
9009 auto topPadding = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument3.value());
9010 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9011 EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
9012 auto rightPadding = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument4.value());
9013 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9014 EnsureStillAliveScope argument5 = callFrame->uncheckedArgument(5);
9015 auto bottomPadding = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument5.value());
9016 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9017 EnsureStillAliveScope argument6 = callFrame->uncheckedArgument(6);
9018 auto leftPadding = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument6.value());
9019 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9020 EnsureStillAliveScope argument7 = callFrame->uncheckedArgument(7);
9021 auto ignoreClipping = convert<IDLBoolean>(*lexicalGlobalObject, argument7.value());
9022 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9023 EnsureStillAliveScope argument8 = callFrame->uncheckedArgument(8);
9024 auto allowShadowContent = convert<IDLBoolean>(*lexicalGlobalObject, argument8.value());
9025 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9026 EnsureStillAliveScope argument9 = callFrame->uncheckedArgument(9);
9027 auto allowChildFrameContent = convert<IDLBoolean>(*lexicalGlobalObject, argument9.value());
9028 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9029 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLInterface<NodeList>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.nodesFromRect(*document, WTFMove(x), WTFMove(y), WTFMove(topPadding), WTFMove(rightPadding), WTFMove(bottomPadding), WTFMove(leftPadding), WTFMove(ignoreClipping), WTFMove(allowShadowContent), WTFMove(allowChildFrameContent)))));
9030}
9031
9032JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_nodesFromRect, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9033{
9034 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_nodesFromRectBody>(*lexicalGlobalObject, *callFrame, "nodesFromRect");
9035}
9036
9037static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_parserMetaDataBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9038{
9039 auto& vm = JSC::getVM(lexicalGlobalObject);
9040 auto throwScope = DECLARE_THROW_SCOPE(vm);
9041 UNUSED_PARAM(throwScope);
9042 UNUSED_PARAM(callFrame);
9043 auto& impl = castedThis->wrapped();
9044 EnsureStillAliveScope argument0 = callFrame->argument(0);
9045 auto func = convert<IDLAny>(*lexicalGlobalObject, argument0.value());
9046 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9047 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.parserMetaData(WTFMove(func)))));
9048}
9049
9050JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_parserMetaData, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9051{
9052 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_parserMetaDataBody>(*lexicalGlobalObject, *callFrame, "parserMetaData");
9053}
9054
9055static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_updateEditorUINowIfScheduledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9056{
9057 auto& vm = JSC::getVM(lexicalGlobalObject);
9058 auto throwScope = DECLARE_THROW_SCOPE(vm);
9059 UNUSED_PARAM(throwScope);
9060 UNUSED_PARAM(callFrame);
9061 auto& impl = castedThis->wrapped();
9062 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.updateEditorUINowIfScheduled(); })));
9063}
9064
9065JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_updateEditorUINowIfScheduled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9066{
9067 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_updateEditorUINowIfScheduledBody>(*lexicalGlobalObject, *callFrame, "updateEditorUINowIfScheduled");
9068}
9069
9070static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_hasSpellingMarkerBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9071{
9072 auto& vm = JSC::getVM(lexicalGlobalObject);
9073 auto throwScope = DECLARE_THROW_SCOPE(vm);
9074 UNUSED_PARAM(throwScope);
9075 UNUSED_PARAM(callFrame);
9076 auto& impl = castedThis->wrapped();
9077 if (UNLIKELY(callFrame->argumentCount() < 2))
9078 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9079 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9080 auto from = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
9081 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9082 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
9083 auto length = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
9084 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9085 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.hasSpellingMarker(WTFMove(from), WTFMove(length)))));
9086}
9087
9088JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasSpellingMarker, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9089{
9090 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_hasSpellingMarkerBody>(*lexicalGlobalObject, *callFrame, "hasSpellingMarker");
9091}
9092
9093static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_hasGrammarMarkerBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9094{
9095 auto& vm = JSC::getVM(lexicalGlobalObject);
9096 auto throwScope = DECLARE_THROW_SCOPE(vm);
9097 UNUSED_PARAM(throwScope);
9098 UNUSED_PARAM(callFrame);
9099 auto& impl = castedThis->wrapped();
9100 if (UNLIKELY(callFrame->argumentCount() < 2))
9101 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9102 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9103 auto from = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
9104 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9105 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
9106 auto length = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
9107 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9108 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.hasGrammarMarker(WTFMove(from), WTFMove(length)))));
9109}
9110
9111JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasGrammarMarker, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9112{
9113 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_hasGrammarMarkerBody>(*lexicalGlobalObject, *callFrame, "hasGrammarMarker");
9114}
9115
9116static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_hasAutocorrectedMarkerBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9117{
9118 auto& vm = JSC::getVM(lexicalGlobalObject);
9119 auto throwScope = DECLARE_THROW_SCOPE(vm);
9120 UNUSED_PARAM(throwScope);
9121 UNUSED_PARAM(callFrame);
9122 auto& impl = castedThis->wrapped();
9123 if (UNLIKELY(callFrame->argumentCount() < 2))
9124 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9125 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9126 auto from = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
9127 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9128 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
9129 auto length = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
9130 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9131 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.hasAutocorrectedMarker(WTFMove(from), WTFMove(length)))));
9132}
9133
9134JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasAutocorrectedMarker, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9135{
9136 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_hasAutocorrectedMarkerBody>(*lexicalGlobalObject, *callFrame, "hasAutocorrectedMarker");
9137}
9138
9139static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_hasDictationAlternativesMarkerBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9140{
9141 auto& vm = JSC::getVM(lexicalGlobalObject);
9142 auto throwScope = DECLARE_THROW_SCOPE(vm);
9143 UNUSED_PARAM(throwScope);
9144 UNUSED_PARAM(callFrame);
9145 auto& impl = castedThis->wrapped();
9146 if (UNLIKELY(callFrame->argumentCount() < 2))
9147 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9148 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9149 auto from = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
9150 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9151 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
9152 auto length = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
9153 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9154 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.hasDictationAlternativesMarker(WTFMove(from), WTFMove(length)))));
9155}
9156
9157JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasDictationAlternativesMarker, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9158{
9159 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_hasDictationAlternativesMarkerBody>(*lexicalGlobalObject, *callFrame, "hasDictationAlternativesMarker");
9160}
9161
9162static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setContinuousSpellCheckingEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9163{
9164 auto& vm = JSC::getVM(lexicalGlobalObject);
9165 auto throwScope = DECLARE_THROW_SCOPE(vm);
9166 UNUSED_PARAM(throwScope);
9167 UNUSED_PARAM(callFrame);
9168 auto& impl = castedThis->wrapped();
9169 if (UNLIKELY(callFrame->argumentCount() < 1))
9170 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9171 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9172 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
9173 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9174 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setContinuousSpellCheckingEnabled(WTFMove(enabled)); })));
9175}
9176
9177JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setContinuousSpellCheckingEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9178{
9179 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setContinuousSpellCheckingEnabledBody>(*lexicalGlobalObject, *callFrame, "setContinuousSpellCheckingEnabled");
9180}
9181
9182static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setAutomaticQuoteSubstitutionEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9183{
9184 auto& vm = JSC::getVM(lexicalGlobalObject);
9185 auto throwScope = DECLARE_THROW_SCOPE(vm);
9186 UNUSED_PARAM(throwScope);
9187 UNUSED_PARAM(callFrame);
9188 auto& impl = castedThis->wrapped();
9189 if (UNLIKELY(callFrame->argumentCount() < 1))
9190 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9191 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9192 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
9193 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9194 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setAutomaticQuoteSubstitutionEnabled(WTFMove(enabled)); })));
9195}
9196
9197JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAutomaticQuoteSubstitutionEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9198{
9199 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setAutomaticQuoteSubstitutionEnabledBody>(*lexicalGlobalObject, *callFrame, "setAutomaticQuoteSubstitutionEnabled");
9200}
9201
9202static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setAutomaticLinkDetectionEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9203{
9204 auto& vm = JSC::getVM(lexicalGlobalObject);
9205 auto throwScope = DECLARE_THROW_SCOPE(vm);
9206 UNUSED_PARAM(throwScope);
9207 UNUSED_PARAM(callFrame);
9208 auto& impl = castedThis->wrapped();
9209 if (UNLIKELY(callFrame->argumentCount() < 1))
9210 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9211 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9212 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
9213 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9214 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setAutomaticLinkDetectionEnabled(WTFMove(enabled)); })));
9215}
9216
9217JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAutomaticLinkDetectionEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9218{
9219 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setAutomaticLinkDetectionEnabledBody>(*lexicalGlobalObject, *callFrame, "setAutomaticLinkDetectionEnabled");
9220}
9221
9222static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setAutomaticDashSubstitutionEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9223{
9224 auto& vm = JSC::getVM(lexicalGlobalObject);
9225 auto throwScope = DECLARE_THROW_SCOPE(vm);
9226 UNUSED_PARAM(throwScope);
9227 UNUSED_PARAM(callFrame);
9228 auto& impl = castedThis->wrapped();
9229 if (UNLIKELY(callFrame->argumentCount() < 1))
9230 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9231 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9232 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
9233 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9234 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setAutomaticDashSubstitutionEnabled(WTFMove(enabled)); })));
9235}
9236
9237JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAutomaticDashSubstitutionEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9238{
9239 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setAutomaticDashSubstitutionEnabledBody>(*lexicalGlobalObject, *callFrame, "setAutomaticDashSubstitutionEnabled");
9240}
9241
9242static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setAutomaticTextReplacementEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9243{
9244 auto& vm = JSC::getVM(lexicalGlobalObject);
9245 auto throwScope = DECLARE_THROW_SCOPE(vm);
9246 UNUSED_PARAM(throwScope);
9247 UNUSED_PARAM(callFrame);
9248 auto& impl = castedThis->wrapped();
9249 if (UNLIKELY(callFrame->argumentCount() < 1))
9250 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9251 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9252 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
9253 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9254 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setAutomaticTextReplacementEnabled(WTFMove(enabled)); })));
9255}
9256
9257JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAutomaticTextReplacementEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9258{
9259 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setAutomaticTextReplacementEnabledBody>(*lexicalGlobalObject, *callFrame, "setAutomaticTextReplacementEnabled");
9260}
9261
9262static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setAutomaticSpellingCorrectionEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9263{
9264 auto& vm = JSC::getVM(lexicalGlobalObject);
9265 auto throwScope = DECLARE_THROW_SCOPE(vm);
9266 UNUSED_PARAM(throwScope);
9267 UNUSED_PARAM(callFrame);
9268 auto& impl = castedThis->wrapped();
9269 if (UNLIKELY(callFrame->argumentCount() < 1))
9270 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9271 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9272 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
9273 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9274 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setAutomaticSpellingCorrectionEnabled(WTFMove(enabled)); })));
9275}
9276
9277JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAutomaticSpellingCorrectionEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9278{
9279 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setAutomaticSpellingCorrectionEnabledBody>(*lexicalGlobalObject, *callFrame, "setAutomaticSpellingCorrectionEnabled");
9280}
9281
9282static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_handleAcceptedCandidateBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9283{
9284 auto& vm = JSC::getVM(lexicalGlobalObject);
9285 auto throwScope = DECLARE_THROW_SCOPE(vm);
9286 UNUSED_PARAM(throwScope);
9287 UNUSED_PARAM(callFrame);
9288 auto& impl = castedThis->wrapped();
9289 if (UNLIKELY(callFrame->argumentCount() < 3))
9290 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9291 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9292 auto candidate = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
9293 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9294 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
9295 auto location = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument1.value());
9296 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9297 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
9298 auto length = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument2.value());
9299 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9300 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.handleAcceptedCandidate(WTFMove(candidate), WTFMove(location), WTFMove(length)); })));
9301}
9302
9303JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_handleAcceptedCandidate, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9304{
9305 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_handleAcceptedCandidateBody>(*lexicalGlobalObject, *callFrame, "handleAcceptedCandidate");
9306}
9307
9308static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_changeSelectionListTypeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9309{
9310 auto& vm = JSC::getVM(lexicalGlobalObject);
9311 auto throwScope = DECLARE_THROW_SCOPE(vm);
9312 UNUSED_PARAM(throwScope);
9313 UNUSED_PARAM(callFrame);
9314 auto& impl = castedThis->wrapped();
9315 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.changeSelectionListType(); })));
9316}
9317
9318JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_changeSelectionListType, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9319{
9320 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_changeSelectionListTypeBody>(*lexicalGlobalObject, *callFrame, "changeSelectionListType");
9321}
9322
9323static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_changeBackToReplacedStringBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9324{
9325 auto& vm = JSC::getVM(lexicalGlobalObject);
9326 auto throwScope = DECLARE_THROW_SCOPE(vm);
9327 UNUSED_PARAM(throwScope);
9328 UNUSED_PARAM(callFrame);
9329 auto& impl = castedThis->wrapped();
9330 if (UNLIKELY(callFrame->argumentCount() < 1))
9331 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9332 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9333 auto replacedString = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
9334 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9335 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.changeBackToReplacedString(WTFMove(replacedString)); })));
9336}
9337
9338JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_changeBackToReplacedString, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9339{
9340 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_changeBackToReplacedStringBody>(*lexicalGlobalObject, *callFrame, "changeBackToReplacedString");
9341}
9342
9343static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isOverwriteModeEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9344{
9345 auto& vm = JSC::getVM(lexicalGlobalObject);
9346 auto throwScope = DECLARE_THROW_SCOPE(vm);
9347 UNUSED_PARAM(throwScope);
9348 UNUSED_PARAM(callFrame);
9349 auto& impl = castedThis->wrapped();
9350 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isOverwriteModeEnabled())));
9351}
9352
9353JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isOverwriteModeEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9354{
9355 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isOverwriteModeEnabledBody>(*lexicalGlobalObject, *callFrame, "isOverwriteModeEnabled");
9356}
9357
9358static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_toggleOverwriteModeEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9359{
9360 auto& vm = JSC::getVM(lexicalGlobalObject);
9361 auto throwScope = DECLARE_THROW_SCOPE(vm);
9362 UNUSED_PARAM(throwScope);
9363 UNUSED_PARAM(callFrame);
9364 auto& impl = castedThis->wrapped();
9365 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.toggleOverwriteModeEnabled(); })));
9366}
9367
9368JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_toggleOverwriteModeEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9369{
9370 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_toggleOverwriteModeEnabledBody>(*lexicalGlobalObject, *callFrame, "toggleOverwriteModeEnabled");
9371}
9372
9373static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_numberOfScrollableAreasBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9374{
9375 auto& vm = JSC::getVM(lexicalGlobalObject);
9376 auto throwScope = DECLARE_THROW_SCOPE(vm);
9377 UNUSED_PARAM(throwScope);
9378 UNUSED_PARAM(callFrame);
9379 auto& impl = castedThis->wrapped();
9380 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.numberOfScrollableAreas())));
9381}
9382
9383JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfScrollableAreas, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9384{
9385 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_numberOfScrollableAreasBody>(*lexicalGlobalObject, *callFrame, "numberOfScrollableAreas");
9386}
9387
9388static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isPageBoxVisibleBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9389{
9390 auto& vm = JSC::getVM(lexicalGlobalObject);
9391 auto throwScope = DECLARE_THROW_SCOPE(vm);
9392 UNUSED_PARAM(throwScope);
9393 UNUSED_PARAM(callFrame);
9394 auto& impl = castedThis->wrapped();
9395 if (UNLIKELY(callFrame->argumentCount() < 1))
9396 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9397 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9398 auto pageNumber = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
9399 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9400 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isPageBoxVisible(WTFMove(pageNumber)))));
9401}
9402
9403JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isPageBoxVisible, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9404{
9405 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isPageBoxVisibleBody>(*lexicalGlobalObject, *callFrame, "isPageBoxVisible");
9406}
9407
9408static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_imageFrameIndexBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9409{
9410 auto& vm = JSC::getVM(lexicalGlobalObject);
9411 auto throwScope = DECLARE_THROW_SCOPE(vm);
9412 UNUSED_PARAM(throwScope);
9413 UNUSED_PARAM(callFrame);
9414 auto& impl = castedThis->wrapped();
9415 if (UNLIKELY(callFrame->argumentCount() < 1))
9416 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9417 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9418 auto element = convert<IDLInterface<HTMLImageElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "imageFrameIndex", "HTMLImageElement"); });
9419 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9420 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.imageFrameIndex(*element))));
9421}
9422
9423JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_imageFrameIndex, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9424{
9425 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_imageFrameIndexBody>(*lexicalGlobalObject, *callFrame, "imageFrameIndex");
9426}
9427
9428static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_imageFrameCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9429{
9430 auto& vm = JSC::getVM(lexicalGlobalObject);
9431 auto throwScope = DECLARE_THROW_SCOPE(vm);
9432 UNUSED_PARAM(throwScope);
9433 UNUSED_PARAM(callFrame);
9434 auto& impl = castedThis->wrapped();
9435 if (UNLIKELY(callFrame->argumentCount() < 1))
9436 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9437 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9438 auto element = convert<IDLInterface<HTMLImageElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "imageFrameCount", "HTMLImageElement"); });
9439 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9440 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.imageFrameCount(*element))));
9441}
9442
9443JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_imageFrameCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9444{
9445 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_imageFrameCountBody>(*lexicalGlobalObject, *callFrame, "imageFrameCount");
9446}
9447
9448static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_imageFrameDurationAtIndexBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9449{
9450 auto& vm = JSC::getVM(lexicalGlobalObject);
9451 auto throwScope = DECLARE_THROW_SCOPE(vm);
9452 UNUSED_PARAM(throwScope);
9453 UNUSED_PARAM(callFrame);
9454 auto& impl = castedThis->wrapped();
9455 if (UNLIKELY(callFrame->argumentCount() < 2))
9456 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9457 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9458 auto element = convert<IDLInterface<HTMLImageElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "imageFrameDurationAtIndex", "HTMLImageElement"); });
9459 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9460 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
9461 auto index = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument1.value());
9462 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9463 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLFloat>(*lexicalGlobalObject, throwScope, impl.imageFrameDurationAtIndex(*element, WTFMove(index)))));
9464}
9465
9466JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_imageFrameDurationAtIndex, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9467{
9468 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_imageFrameDurationAtIndexBody>(*lexicalGlobalObject, *callFrame, "imageFrameDurationAtIndex");
9469}
9470
9471static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setImageFrameDecodingDurationBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9472{
9473 auto& vm = JSC::getVM(lexicalGlobalObject);
9474 auto throwScope = DECLARE_THROW_SCOPE(vm);
9475 UNUSED_PARAM(throwScope);
9476 UNUSED_PARAM(callFrame);
9477 auto& impl = castedThis->wrapped();
9478 if (UNLIKELY(callFrame->argumentCount() < 2))
9479 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9480 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9481 auto element = convert<IDLInterface<HTMLImageElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "setImageFrameDecodingDuration", "HTMLImageElement"); });
9482 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9483 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
9484 auto duration = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument1.value());
9485 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9486 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setImageFrameDecodingDuration(*element, WTFMove(duration)); })));
9487}
9488
9489JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setImageFrameDecodingDuration, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9490{
9491 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setImageFrameDecodingDurationBody>(*lexicalGlobalObject, *callFrame, "setImageFrameDecodingDuration");
9492}
9493
9494static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_resetImageAnimationBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9495{
9496 auto& vm = JSC::getVM(lexicalGlobalObject);
9497 auto throwScope = DECLARE_THROW_SCOPE(vm);
9498 UNUSED_PARAM(throwScope);
9499 UNUSED_PARAM(callFrame);
9500 auto& impl = castedThis->wrapped();
9501 if (UNLIKELY(callFrame->argumentCount() < 1))
9502 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9503 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9504 auto element = convert<IDLInterface<HTMLImageElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "resetImageAnimation", "HTMLImageElement"); });
9505 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9506 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.resetImageAnimation(*element); })));
9507}
9508
9509JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_resetImageAnimation, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9510{
9511 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_resetImageAnimationBody>(*lexicalGlobalObject, *callFrame, "resetImageAnimation");
9512}
9513
9514static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isImageAnimatingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9515{
9516 auto& vm = JSC::getVM(lexicalGlobalObject);
9517 auto throwScope = DECLARE_THROW_SCOPE(vm);
9518 UNUSED_PARAM(throwScope);
9519 UNUSED_PARAM(callFrame);
9520 auto& impl = castedThis->wrapped();
9521 if (UNLIKELY(callFrame->argumentCount() < 1))
9522 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9523 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9524 auto element = convert<IDLInterface<HTMLImageElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "isImageAnimating", "HTMLImageElement"); });
9525 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9526 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isImageAnimating(*element))));
9527}
9528
9529JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isImageAnimating, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9530{
9531 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isImageAnimatingBody>(*lexicalGlobalObject, *callFrame, "isImageAnimating");
9532}
9533
9534static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_imagePendingDecodePromisesCountForTestingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9535{
9536 auto& vm = JSC::getVM(lexicalGlobalObject);
9537 auto throwScope = DECLARE_THROW_SCOPE(vm);
9538 UNUSED_PARAM(throwScope);
9539 UNUSED_PARAM(callFrame);
9540 auto& impl = castedThis->wrapped();
9541 if (UNLIKELY(callFrame->argumentCount() < 1))
9542 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9543 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9544 auto element = convert<IDLInterface<HTMLImageElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "imagePendingDecodePromisesCountForTesting", "HTMLImageElement"); });
9545 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9546 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.imagePendingDecodePromisesCountForTesting(*element))));
9547}
9548
9549JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_imagePendingDecodePromisesCountForTesting, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9550{
9551 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_imagePendingDecodePromisesCountForTestingBody>(*lexicalGlobalObject, *callFrame, "imagePendingDecodePromisesCountForTesting");
9552}
9553
9554static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setClearDecoderAfterAsyncFrameRequestForTestingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9555{
9556 auto& vm = JSC::getVM(lexicalGlobalObject);
9557 auto throwScope = DECLARE_THROW_SCOPE(vm);
9558 UNUSED_PARAM(throwScope);
9559 UNUSED_PARAM(callFrame);
9560 auto& impl = castedThis->wrapped();
9561 if (UNLIKELY(callFrame->argumentCount() < 2))
9562 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9563 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9564 auto element = convert<IDLInterface<HTMLImageElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "setClearDecoderAfterAsyncFrameRequestForTesting", "HTMLImageElement"); });
9565 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9566 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
9567 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
9568 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9569 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setClearDecoderAfterAsyncFrameRequestForTesting(*element, WTFMove(enabled)); })));
9570}
9571
9572JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setClearDecoderAfterAsyncFrameRequestForTesting, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9573{
9574 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setClearDecoderAfterAsyncFrameRequestForTestingBody>(*lexicalGlobalObject, *callFrame, "setClearDecoderAfterAsyncFrameRequestForTesting");
9575}
9576
9577static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_imageDecodeCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9578{
9579 auto& vm = JSC::getVM(lexicalGlobalObject);
9580 auto throwScope = DECLARE_THROW_SCOPE(vm);
9581 UNUSED_PARAM(throwScope);
9582 UNUSED_PARAM(callFrame);
9583 auto& impl = castedThis->wrapped();
9584 if (UNLIKELY(callFrame->argumentCount() < 1))
9585 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9586 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9587 auto element = convert<IDLInterface<HTMLImageElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "imageDecodeCount", "HTMLImageElement"); });
9588 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9589 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.imageDecodeCount(*element))));
9590}
9591
9592JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_imageDecodeCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9593{
9594 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_imageDecodeCountBody>(*lexicalGlobalObject, *callFrame, "imageDecodeCount");
9595}
9596
9597static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pdfDocumentCachingCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9598{
9599 auto& vm = JSC::getVM(lexicalGlobalObject);
9600 auto throwScope = DECLARE_THROW_SCOPE(vm);
9601 UNUSED_PARAM(throwScope);
9602 UNUSED_PARAM(callFrame);
9603 auto& impl = castedThis->wrapped();
9604 if (UNLIKELY(callFrame->argumentCount() < 1))
9605 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9606 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9607 auto element = convert<IDLInterface<HTMLImageElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "pdfDocumentCachingCount", "HTMLImageElement"); });
9608 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9609 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.pdfDocumentCachingCount(*element))));
9610}
9611
9612JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pdfDocumentCachingCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9613{
9614 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pdfDocumentCachingCountBody>(*lexicalGlobalObject, *callFrame, "pdfDocumentCachingCount");
9615}
9616
9617static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setLargeImageAsyncDecodingEnabledForTestingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9618{
9619 auto& vm = JSC::getVM(lexicalGlobalObject);
9620 auto throwScope = DECLARE_THROW_SCOPE(vm);
9621 UNUSED_PARAM(throwScope);
9622 UNUSED_PARAM(callFrame);
9623 auto& impl = castedThis->wrapped();
9624 if (UNLIKELY(callFrame->argumentCount() < 2))
9625 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9626 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9627 auto element = convert<IDLInterface<HTMLImageElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "setLargeImageAsyncDecodingEnabledForTesting", "HTMLImageElement"); });
9628 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9629 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
9630 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
9631 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9632 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setLargeImageAsyncDecodingEnabledForTesting(*element, WTFMove(enabled)); })));
9633}
9634
9635JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setLargeImageAsyncDecodingEnabledForTesting, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9636{
9637 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setLargeImageAsyncDecodingEnabledForTestingBody>(*lexicalGlobalObject, *callFrame, "setLargeImageAsyncDecodingEnabledForTesting");
9638}
9639
9640static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setForceUpdateImageDataEnabledForTestingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9641{
9642 auto& vm = JSC::getVM(lexicalGlobalObject);
9643 auto throwScope = DECLARE_THROW_SCOPE(vm);
9644 UNUSED_PARAM(throwScope);
9645 UNUSED_PARAM(callFrame);
9646 auto& impl = castedThis->wrapped();
9647 if (UNLIKELY(callFrame->argumentCount() < 2))
9648 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9649 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9650 auto element = convert<IDLInterface<HTMLImageElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "setForceUpdateImageDataEnabledForTesting", "HTMLImageElement"); });
9651 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9652 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
9653 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
9654 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9655 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setForceUpdateImageDataEnabledForTesting(*element, WTFMove(enabled)); })));
9656}
9657
9658JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setForceUpdateImageDataEnabledForTesting, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9659{
9660 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setForceUpdateImageDataEnabledForTestingBody>(*lexicalGlobalObject, *callFrame, "setForceUpdateImageDataEnabledForTesting");
9661}
9662
9663static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setGridMaxTracksLimitBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9664{
9665 auto& vm = JSC::getVM(lexicalGlobalObject);
9666 auto throwScope = DECLARE_THROW_SCOPE(vm);
9667 UNUSED_PARAM(throwScope);
9668 UNUSED_PARAM(callFrame);
9669 auto& impl = castedThis->wrapped();
9670 if (UNLIKELY(callFrame->argumentCount() < 1))
9671 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9672 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9673 auto maxTracksLimit = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument0.value());
9674 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9675 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setGridMaxTracksLimit(WTFMove(maxTracksLimit)); })));
9676}
9677
9678JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setGridMaxTracksLimit, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9679{
9680 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setGridMaxTracksLimitBody>(*lexicalGlobalObject, *callFrame, "setGridMaxTracksLimit");
9681}
9682
9683static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_svgAnimationsIntervalBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9684{
9685 auto& vm = JSC::getVM(lexicalGlobalObject);
9686 auto throwScope = DECLARE_THROW_SCOPE(vm);
9687 UNUSED_PARAM(throwScope);
9688 UNUSED_PARAM(callFrame);
9689 auto& impl = castedThis->wrapped();
9690 if (UNLIKELY(callFrame->argumentCount() < 1))
9691 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9692 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9693 auto element = convert<IDLInterface<SVGSVGElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "svgAnimationsInterval", "SVGSVGElement"); });
9694 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9695 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.svgAnimationsInterval(*element))));
9696}
9697
9698JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_svgAnimationsInterval, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9699{
9700 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_svgAnimationsIntervalBody>(*lexicalGlobalObject, *callFrame, "svgAnimationsInterval");
9701}
9702
9703static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_testProcessIncomingSyncMessagesWhenWaitingForSyncReplyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9704{
9705 auto& vm = JSC::getVM(lexicalGlobalObject);
9706 auto throwScope = DECLARE_THROW_SCOPE(vm);
9707 UNUSED_PARAM(throwScope);
9708 UNUSED_PARAM(callFrame);
9709 auto& impl = castedThis->wrapped();
9710 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.testProcessIncomingSyncMessagesWhenWaitingForSyncReply())));
9711}
9712
9713JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_testProcessIncomingSyncMessagesWhenWaitingForSyncReply, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9714{
9715 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_testProcessIncomingSyncMessagesWhenWaitingForSyncReplyBody>(*lexicalGlobalObject, *callFrame, "testProcessIncomingSyncMessagesWhenWaitingForSyncReply");
9716}
9717
9718static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_layerTreeAsTextBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9719{
9720 auto& vm = JSC::getVM(lexicalGlobalObject);
9721 auto throwScope = DECLARE_THROW_SCOPE(vm);
9722 UNUSED_PARAM(throwScope);
9723 UNUSED_PARAM(callFrame);
9724 auto& impl = castedThis->wrapped();
9725 if (UNLIKELY(callFrame->argumentCount() < 1))
9726 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9727 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9728 auto document = convert<IDLInterface<Document>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "document", "Internals", "layerTreeAsText", "Document"); });
9729 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9730 EnsureStillAliveScope argument1 = callFrame->argument(1);
9731 auto flags = convert<IDLUnsignedShort>(*lexicalGlobalObject, argument1.value());
9732 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9733 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.layerTreeAsText(*document, WTFMove(flags)))));
9734}
9735
9736JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_layerTreeAsText, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9737{
9738 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_layerTreeAsTextBody>(*lexicalGlobalObject, *callFrame, "layerTreeAsText");
9739}
9740
9741static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_layerIDForElementBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9742{
9743 auto& vm = JSC::getVM(lexicalGlobalObject);
9744 auto throwScope = DECLARE_THROW_SCOPE(vm);
9745 UNUSED_PARAM(throwScope);
9746 UNUSED_PARAM(callFrame);
9747 auto& impl = castedThis->wrapped();
9748 if (UNLIKELY(callFrame->argumentCount() < 1))
9749 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9750 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9751 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "layerIDForElement", "Element"); });
9752 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9753 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLongLong>(*lexicalGlobalObject, throwScope, impl.layerIDForElement(*element))));
9754}
9755
9756JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_layerIDForElement, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9757{
9758 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_layerIDForElementBody>(*lexicalGlobalObject, *callFrame, "layerIDForElement");
9759}
9760
9761static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_platformLayerTreeAsTextBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9762{
9763 auto& vm = JSC::getVM(lexicalGlobalObject);
9764 auto throwScope = DECLARE_THROW_SCOPE(vm);
9765 UNUSED_PARAM(throwScope);
9766 UNUSED_PARAM(callFrame);
9767 auto& impl = castedThis->wrapped();
9768 if (UNLIKELY(callFrame->argumentCount() < 1))
9769 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9770 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9771 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "platformLayerTreeAsText", "Element"); });
9772 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9773 EnsureStillAliveScope argument1 = callFrame->argument(1);
9774 auto flags = convert<IDLUnsignedShort>(*lexicalGlobalObject, argument1.value());
9775 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9776 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.platformLayerTreeAsText(*element, WTFMove(flags)))));
9777}
9778
9779JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_platformLayerTreeAsText, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9780{
9781 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_platformLayerTreeAsTextBody>(*lexicalGlobalObject, *callFrame, "platformLayerTreeAsText");
9782}
9783
9784static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_scrollbarOverlayStyleBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9785{
9786 auto& vm = JSC::getVM(lexicalGlobalObject);
9787 auto throwScope = DECLARE_THROW_SCOPE(vm);
9788 UNUSED_PARAM(throwScope);
9789 UNUSED_PARAM(callFrame);
9790 auto& impl = castedThis->wrapped();
9791 EnsureStillAliveScope argument0 = callFrame->argument(0);
9792 auto node = convert<IDLNullable<IDLInterface<Node>>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "node", "Internals", "scrollbarOverlayStyle", "Node"); });
9793 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9794 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.scrollbarOverlayStyle(WTFMove(node)))));
9795}
9796
9797JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_scrollbarOverlayStyle, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9798{
9799 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_scrollbarOverlayStyleBody>(*lexicalGlobalObject, *callFrame, "scrollbarOverlayStyle");
9800}
9801
9802static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_scrollbarUsingDarkAppearanceBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9803{
9804 auto& vm = JSC::getVM(lexicalGlobalObject);
9805 auto throwScope = DECLARE_THROW_SCOPE(vm);
9806 UNUSED_PARAM(throwScope);
9807 UNUSED_PARAM(callFrame);
9808 auto& impl = castedThis->wrapped();
9809 EnsureStillAliveScope argument0 = callFrame->argument(0);
9810 auto node = convert<IDLNullable<IDLInterface<Node>>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "node", "Internals", "scrollbarUsingDarkAppearance", "Node"); });
9811 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9812 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.scrollbarUsingDarkAppearance(WTFMove(node)))));
9813}
9814
9815JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_scrollbarUsingDarkAppearance, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9816{
9817 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_scrollbarUsingDarkAppearanceBody>(*lexicalGlobalObject, *callFrame, "scrollbarUsingDarkAppearance");
9818}
9819
9820static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_horizontalScrollbarStateBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9821{
9822 auto& vm = JSC::getVM(lexicalGlobalObject);
9823 auto throwScope = DECLARE_THROW_SCOPE(vm);
9824 UNUSED_PARAM(throwScope);
9825 UNUSED_PARAM(callFrame);
9826 auto& impl = castedThis->wrapped();
9827 EnsureStillAliveScope argument0 = callFrame->argument(0);
9828 auto node = convert<IDLNullable<IDLInterface<Node>>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "node", "Internals", "horizontalScrollbarState", "Node"); });
9829 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9830 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.horizontalScrollbarState(WTFMove(node)))));
9831}
9832
9833JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_horizontalScrollbarState, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9834{
9835 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_horizontalScrollbarStateBody>(*lexicalGlobalObject, *callFrame, "horizontalScrollbarState");
9836}
9837
9838static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_verticalScrollbarStateBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9839{
9840 auto& vm = JSC::getVM(lexicalGlobalObject);
9841 auto throwScope = DECLARE_THROW_SCOPE(vm);
9842 UNUSED_PARAM(throwScope);
9843 UNUSED_PARAM(callFrame);
9844 auto& impl = castedThis->wrapped();
9845 EnsureStillAliveScope argument0 = callFrame->argument(0);
9846 auto node = convert<IDLNullable<IDLInterface<Node>>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "node", "Internals", "verticalScrollbarState", "Node"); });
9847 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9848 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.verticalScrollbarState(WTFMove(node)))));
9849}
9850
9851JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_verticalScrollbarState, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9852{
9853 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_verticalScrollbarStateBody>(*lexicalGlobalObject, *callFrame, "verticalScrollbarState");
9854}
9855
9856static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_scrollingStateTreeAsTextBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9857{
9858 auto& vm = JSC::getVM(lexicalGlobalObject);
9859 auto throwScope = DECLARE_THROW_SCOPE(vm);
9860 UNUSED_PARAM(throwScope);
9861 UNUSED_PARAM(callFrame);
9862 auto& impl = castedThis->wrapped();
9863 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.scrollingStateTreeAsText())));
9864}
9865
9866JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_scrollingStateTreeAsText, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9867{
9868 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_scrollingStateTreeAsTextBody>(*lexicalGlobalObject, *callFrame, "scrollingStateTreeAsText");
9869}
9870
9871static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_scrollingTreeAsTextBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9872{
9873 auto& vm = JSC::getVM(lexicalGlobalObject);
9874 auto throwScope = DECLARE_THROW_SCOPE(vm);
9875 UNUSED_PARAM(throwScope);
9876 UNUSED_PARAM(callFrame);
9877 auto& impl = castedThis->wrapped();
9878 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.scrollingTreeAsText())));
9879}
9880
9881JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_scrollingTreeAsText, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9882{
9883 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_scrollingTreeAsTextBody>(*lexicalGlobalObject, *callFrame, "scrollingTreeAsText");
9884}
9885
9886static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_synchronousScrollingReasonsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9887{
9888 auto& vm = JSC::getVM(lexicalGlobalObject);
9889 auto throwScope = DECLARE_THROW_SCOPE(vm);
9890 UNUSED_PARAM(throwScope);
9891 UNUSED_PARAM(callFrame);
9892 auto& impl = castedThis->wrapped();
9893 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.synchronousScrollingReasons())));
9894}
9895
9896JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_synchronousScrollingReasons, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9897{
9898 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_synchronousScrollingReasonsBody>(*lexicalGlobalObject, *callFrame, "synchronousScrollingReasons");
9899}
9900
9901static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_nonFastScrollableRectsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9902{
9903 auto& vm = JSC::getVM(lexicalGlobalObject);
9904 auto throwScope = DECLARE_THROW_SCOPE(vm);
9905 UNUSED_PARAM(throwScope);
9906 UNUSED_PARAM(callFrame);
9907 auto& impl = castedThis->wrapped();
9908 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<DOMRectList>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.nonFastScrollableRects())));
9909}
9910
9911JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_nonFastScrollableRects, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9912{
9913 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_nonFastScrollableRectsBody>(*lexicalGlobalObject, *callFrame, "nonFastScrollableRects");
9914}
9915
9916static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_repaintRectsAsTextBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9917{
9918 auto& vm = JSC::getVM(lexicalGlobalObject);
9919 auto throwScope = DECLARE_THROW_SCOPE(vm);
9920 UNUSED_PARAM(throwScope);
9921 UNUSED_PARAM(callFrame);
9922 auto& impl = castedThis->wrapped();
9923 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.repaintRectsAsText())));
9924}
9925
9926JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_repaintRectsAsText, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9927{
9928 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_repaintRectsAsTextBody>(*lexicalGlobalObject, *callFrame, "repaintRectsAsText");
9929}
9930
9931static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setElementUsesDisplayListDrawingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9932{
9933 auto& vm = JSC::getVM(lexicalGlobalObject);
9934 auto throwScope = DECLARE_THROW_SCOPE(vm);
9935 UNUSED_PARAM(throwScope);
9936 UNUSED_PARAM(callFrame);
9937 auto& impl = castedThis->wrapped();
9938 if (UNLIKELY(callFrame->argumentCount() < 2))
9939 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9940 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9941 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "setElementUsesDisplayListDrawing", "Element"); });
9942 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9943 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
9944 auto usesDisplayListDrawing = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
9945 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9946 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setElementUsesDisplayListDrawing(*element, WTFMove(usesDisplayListDrawing)); })));
9947}
9948
9949JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setElementUsesDisplayListDrawing, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9950{
9951 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setElementUsesDisplayListDrawingBody>(*lexicalGlobalObject, *callFrame, "setElementUsesDisplayListDrawing");
9952}
9953
9954static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setElementTracksDisplayListReplayBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9955{
9956 auto& vm = JSC::getVM(lexicalGlobalObject);
9957 auto throwScope = DECLARE_THROW_SCOPE(vm);
9958 UNUSED_PARAM(throwScope);
9959 UNUSED_PARAM(callFrame);
9960 auto& impl = castedThis->wrapped();
9961 if (UNLIKELY(callFrame->argumentCount() < 2))
9962 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9963 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9964 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "setElementTracksDisplayListReplay", "Element"); });
9965 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9966 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
9967 auto trackReplay = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
9968 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9969 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setElementTracksDisplayListReplay(*element, WTFMove(trackReplay)); })));
9970}
9971
9972JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setElementTracksDisplayListReplay, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9973{
9974 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setElementTracksDisplayListReplayBody>(*lexicalGlobalObject, *callFrame, "setElementTracksDisplayListReplay");
9975}
9976
9977static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_displayListForElementBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
9978{
9979 auto& vm = JSC::getVM(lexicalGlobalObject);
9980 auto throwScope = DECLARE_THROW_SCOPE(vm);
9981 UNUSED_PARAM(throwScope);
9982 UNUSED_PARAM(callFrame);
9983 auto& impl = castedThis->wrapped();
9984 if (UNLIKELY(callFrame->argumentCount() < 1))
9985 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
9986 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
9987 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "displayListForElement", "Element"); });
9988 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9989 EnsureStillAliveScope argument1 = callFrame->argument(1);
9990 auto flags = convert<IDLUnsignedShort>(*lexicalGlobalObject, argument1.value());
9991 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9992 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.displayListForElement(*element, WTFMove(flags)))));
9993}
9994
9995JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_displayListForElement, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
9996{
9997 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_displayListForElementBody>(*lexicalGlobalObject, *callFrame, "displayListForElement");
9998}
9999
10000static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_replayDisplayListForElementBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10001{
10002 auto& vm = JSC::getVM(lexicalGlobalObject);
10003 auto throwScope = DECLARE_THROW_SCOPE(vm);
10004 UNUSED_PARAM(throwScope);
10005 UNUSED_PARAM(callFrame);
10006 auto& impl = castedThis->wrapped();
10007 if (UNLIKELY(callFrame->argumentCount() < 1))
10008 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10009 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10010 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "replayDisplayListForElement", "Element"); });
10011 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10012 EnsureStillAliveScope argument1 = callFrame->argument(1);
10013 auto flags = convert<IDLUnsignedShort>(*lexicalGlobalObject, argument1.value());
10014 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10015 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.replayDisplayListForElement(*element, WTFMove(flags)))));
10016}
10017
10018JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_replayDisplayListForElement, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10019{
10020 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_replayDisplayListForElementBody>(*lexicalGlobalObject, *callFrame, "replayDisplayListForElement");
10021}
10022
10023static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_garbageCollectDocumentResourcesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10024{
10025 auto& vm = JSC::getVM(lexicalGlobalObject);
10026 auto throwScope = DECLARE_THROW_SCOPE(vm);
10027 UNUSED_PARAM(throwScope);
10028 UNUSED_PARAM(callFrame);
10029 auto& impl = castedThis->wrapped();
10030 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.garbageCollectDocumentResources(); })));
10031}
10032
10033JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_garbageCollectDocumentResources, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10034{
10035 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_garbageCollectDocumentResourcesBody>(*lexicalGlobalObject, *callFrame, "garbageCollectDocumentResources");
10036}
10037
10038static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_insertAuthorCSSBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10039{
10040 auto& vm = JSC::getVM(lexicalGlobalObject);
10041 auto throwScope = DECLARE_THROW_SCOPE(vm);
10042 UNUSED_PARAM(throwScope);
10043 UNUSED_PARAM(callFrame);
10044 auto& impl = castedThis->wrapped();
10045 if (UNLIKELY(callFrame->argumentCount() < 1))
10046 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10047 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10048 auto css = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
10049 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10050 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.insertAuthorCSS(WTFMove(css)); })));
10051}
10052
10053JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_insertAuthorCSS, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10054{
10055 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_insertAuthorCSSBody>(*lexicalGlobalObject, *callFrame, "insertAuthorCSS");
10056}
10057
10058static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_insertUserCSSBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10059{
10060 auto& vm = JSC::getVM(lexicalGlobalObject);
10061 auto throwScope = DECLARE_THROW_SCOPE(vm);
10062 UNUSED_PARAM(throwScope);
10063 UNUSED_PARAM(callFrame);
10064 auto& impl = castedThis->wrapped();
10065 if (UNLIKELY(callFrame->argumentCount() < 1))
10066 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10067 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10068 auto css = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
10069 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10070 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.insertUserCSS(WTFMove(css)); })));
10071}
10072
10073JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_insertUserCSS, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10074{
10075 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_insertUserCSSBody>(*lexicalGlobalObject, *callFrame, "insertUserCSS");
10076}
10077
10078static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_beginSimulatedMemoryPressureBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10079{
10080 auto& vm = JSC::getVM(lexicalGlobalObject);
10081 auto throwScope = DECLARE_THROW_SCOPE(vm);
10082 UNUSED_PARAM(throwScope);
10083 UNUSED_PARAM(callFrame);
10084 auto& impl = castedThis->wrapped();
10085 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.beginSimulatedMemoryPressure(); })));
10086}
10087
10088JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_beginSimulatedMemoryPressure, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10089{
10090 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_beginSimulatedMemoryPressureBody>(*lexicalGlobalObject, *callFrame, "beginSimulatedMemoryPressure");
10091}
10092
10093static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_endSimulatedMemoryPressureBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10094{
10095 auto& vm = JSC::getVM(lexicalGlobalObject);
10096 auto throwScope = DECLARE_THROW_SCOPE(vm);
10097 UNUSED_PARAM(throwScope);
10098 UNUSED_PARAM(callFrame);
10099 auto& impl = castedThis->wrapped();
10100 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.endSimulatedMemoryPressure(); })));
10101}
10102
10103JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_endSimulatedMemoryPressure, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10104{
10105 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_endSimulatedMemoryPressureBody>(*lexicalGlobalObject, *callFrame, "endSimulatedMemoryPressure");
10106}
10107
10108static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_numberOfIDBTransactionsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10109{
10110 auto& vm = JSC::getVM(lexicalGlobalObject);
10111 auto throwScope = DECLARE_THROW_SCOPE(vm);
10112 UNUSED_PARAM(throwScope);
10113 UNUSED_PARAM(callFrame);
10114 auto& impl = castedThis->wrapped();
10115 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.numberOfIDBTransactions())));
10116}
10117
10118JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfIDBTransactions, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10119{
10120 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_numberOfIDBTransactionsBody>(*lexicalGlobalObject, *callFrame, "numberOfIDBTransactions");
10121}
10122
10123static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_numberOfLiveNodesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10124{
10125 auto& vm = JSC::getVM(lexicalGlobalObject);
10126 auto throwScope = DECLARE_THROW_SCOPE(vm);
10127 UNUSED_PARAM(throwScope);
10128 UNUSED_PARAM(callFrame);
10129 auto& impl = castedThis->wrapped();
10130 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.numberOfLiveNodes())));
10131}
10132
10133JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfLiveNodes, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10134{
10135 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_numberOfLiveNodesBody>(*lexicalGlobalObject, *callFrame, "numberOfLiveNodes");
10136}
10137
10138static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_numberOfLiveDocumentsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10139{
10140 auto& vm = JSC::getVM(lexicalGlobalObject);
10141 auto throwScope = DECLARE_THROW_SCOPE(vm);
10142 UNUSED_PARAM(throwScope);
10143 UNUSED_PARAM(callFrame);
10144 auto& impl = castedThis->wrapped();
10145 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.numberOfLiveDocuments())));
10146}
10147
10148JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfLiveDocuments, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10149{
10150 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_numberOfLiveDocumentsBody>(*lexicalGlobalObject, *callFrame, "numberOfLiveDocuments");
10151}
10152
10153static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_referencingNodeCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10154{
10155 auto& vm = JSC::getVM(lexicalGlobalObject);
10156 auto throwScope = DECLARE_THROW_SCOPE(vm);
10157 UNUSED_PARAM(throwScope);
10158 UNUSED_PARAM(callFrame);
10159 auto& impl = castedThis->wrapped();
10160 if (UNLIKELY(callFrame->argumentCount() < 1))
10161 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10162 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10163 auto document = convert<IDLInterface<Document>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "document", "Internals", "referencingNodeCount", "Document"); });
10164 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10165 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.referencingNodeCount(*document))));
10166}
10167
10168JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_referencingNodeCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10169{
10170 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_referencingNodeCountBody>(*lexicalGlobalObject, *callFrame, "referencingNodeCount");
10171}
10172
10173#if ENABLE(INTERSECTION_OBSERVER)
10174static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_numberOfIntersectionObserversBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10175{
10176 auto& vm = JSC::getVM(lexicalGlobalObject);
10177 auto throwScope = DECLARE_THROW_SCOPE(vm);
10178 UNUSED_PARAM(throwScope);
10179 UNUSED_PARAM(callFrame);
10180 auto& impl = castedThis->wrapped();
10181 if (UNLIKELY(callFrame->argumentCount() < 1))
10182 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10183 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10184 auto document = convert<IDLInterface<Document>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "document", "Internals", "numberOfIntersectionObservers", "Document"); });
10185 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10186 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.numberOfIntersectionObservers(*document))));
10187}
10188
10189JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfIntersectionObservers, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10190{
10191 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_numberOfIntersectionObserversBody>(*lexicalGlobalObject, *callFrame, "numberOfIntersectionObservers");
10192}
10193
10194#endif
10195
10196#if ENABLE(RESIZE_OBSERVER)
10197static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_numberOfResizeObserversBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10198{
10199 auto& vm = JSC::getVM(lexicalGlobalObject);
10200 auto throwScope = DECLARE_THROW_SCOPE(vm);
10201 UNUSED_PARAM(throwScope);
10202 UNUSED_PARAM(callFrame);
10203 auto& impl = castedThis->wrapped();
10204 if (UNLIKELY(callFrame->argumentCount() < 1))
10205 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10206 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10207 auto document = convert<IDLInterface<Document>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "document", "Internals", "numberOfResizeObservers", "Document"); });
10208 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10209 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.numberOfResizeObservers(*document))));
10210}
10211
10212JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfResizeObservers, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10213{
10214 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_numberOfResizeObserversBody>(*lexicalGlobalObject, *callFrame, "numberOfResizeObservers");
10215}
10216
10217#endif
10218
10219static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_openDummyInspectorFrontendBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10220{
10221 auto& vm = JSC::getVM(lexicalGlobalObject);
10222 auto throwScope = DECLARE_THROW_SCOPE(vm);
10223 UNUSED_PARAM(throwScope);
10224 UNUSED_PARAM(callFrame);
10225 auto& impl = castedThis->wrapped();
10226 if (UNLIKELY(callFrame->argumentCount() < 1))
10227 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10228 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10229 auto url = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
10230 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10231 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLInterface<WindowProxy>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.openDummyInspectorFrontend(WTFMove(url)))));
10232}
10233
10234JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_openDummyInspectorFrontend, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10235{
10236 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_openDummyInspectorFrontendBody>(*lexicalGlobalObject, *callFrame, "openDummyInspectorFrontend");
10237}
10238
10239static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_closeDummyInspectorFrontendBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10240{
10241 auto& vm = JSC::getVM(lexicalGlobalObject);
10242 auto throwScope = DECLARE_THROW_SCOPE(vm);
10243 UNUSED_PARAM(throwScope);
10244 UNUSED_PARAM(callFrame);
10245 auto& impl = castedThis->wrapped();
10246 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.closeDummyInspectorFrontend(); })));
10247}
10248
10249JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_closeDummyInspectorFrontend, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10250{
10251 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_closeDummyInspectorFrontendBody>(*lexicalGlobalObject, *callFrame, "closeDummyInspectorFrontend");
10252}
10253
10254static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setInspectorIsUnderTestBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10255{
10256 auto& vm = JSC::getVM(lexicalGlobalObject);
10257 auto throwScope = DECLARE_THROW_SCOPE(vm);
10258 UNUSED_PARAM(throwScope);
10259 UNUSED_PARAM(callFrame);
10260 auto& impl = castedThis->wrapped();
10261 if (UNLIKELY(callFrame->argumentCount() < 1))
10262 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10263 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10264 auto isUnderTest = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
10265 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10266 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setInspectorIsUnderTest(WTFMove(isUnderTest)); })));
10267}
10268
10269JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setInspectorIsUnderTest, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10270{
10271 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setInspectorIsUnderTestBody>(*lexicalGlobalObject, *callFrame, "setInspectorIsUnderTest");
10272}
10273
10274#if ENABLE(WEB_AUDIO)
10275static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_baseAudioContextIdentifierBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10276{
10277 auto& vm = JSC::getVM(lexicalGlobalObject);
10278 auto throwScope = DECLARE_THROW_SCOPE(vm);
10279 UNUSED_PARAM(throwScope);
10280 UNUSED_PARAM(callFrame);
10281 auto& impl = castedThis->wrapped();
10282 if (UNLIKELY(callFrame->argumentCount() < 1))
10283 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10284 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10285 auto context = convert<IDLInterface<BaseAudioContext>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "context", "Internals", "baseAudioContextIdentifier", "BaseAudioContext"); });
10286 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10287 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLongLong>(*lexicalGlobalObject, throwScope, impl.baseAudioContextIdentifier(*context))));
10288}
10289
10290JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_baseAudioContextIdentifier, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10291{
10292 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_baseAudioContextIdentifierBody>(*lexicalGlobalObject, *callFrame, "baseAudioContextIdentifier");
10293}
10294
10295#endif
10296
10297#if ENABLE(WEB_AUDIO)
10298static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isBaseAudioContextAliveBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10299{
10300 auto& vm = JSC::getVM(lexicalGlobalObject);
10301 auto throwScope = DECLARE_THROW_SCOPE(vm);
10302 UNUSED_PARAM(throwScope);
10303 UNUSED_PARAM(callFrame);
10304 auto& impl = castedThis->wrapped();
10305 if (UNLIKELY(callFrame->argumentCount() < 1))
10306 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10307 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10308 auto contextID = convert<IDLUnsignedLongLong>(*lexicalGlobalObject, argument0.value());
10309 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10310 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isBaseAudioContextAlive(WTFMove(contextID)))));
10311}
10312
10313JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isBaseAudioContextAlive, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10314{
10315 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isBaseAudioContextAliveBody>(*lexicalGlobalObject, *callFrame, "isBaseAudioContextAlive");
10316}
10317
10318#endif
10319
10320static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_counterValueBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10321{
10322 auto& vm = JSC::getVM(lexicalGlobalObject);
10323 auto throwScope = DECLARE_THROW_SCOPE(vm);
10324 UNUSED_PARAM(throwScope);
10325 UNUSED_PARAM(callFrame);
10326 auto& impl = castedThis->wrapped();
10327 if (UNLIKELY(callFrame->argumentCount() < 1))
10328 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10329 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10330 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "counterValue", "Element"); });
10331 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10332 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.counterValue(*element))));
10333}
10334
10335JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_counterValue, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10336{
10337 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_counterValueBody>(*lexicalGlobalObject, *callFrame, "counterValue");
10338}
10339
10340static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pageNumberBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10341{
10342 auto& vm = JSC::getVM(lexicalGlobalObject);
10343 auto throwScope = DECLARE_THROW_SCOPE(vm);
10344 UNUSED_PARAM(throwScope);
10345 UNUSED_PARAM(callFrame);
10346 auto& impl = castedThis->wrapped();
10347 if (UNLIKELY(callFrame->argumentCount() < 1))
10348 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10349 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10350 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "pageNumber", "Element"); });
10351 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10352 EnsureStillAliveScope argument1 = callFrame->argument(1);
10353 auto pageWidth = argument1.value().isUndefined() ? 800 : convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument1.value());
10354 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10355 EnsureStillAliveScope argument2 = callFrame->argument(2);
10356 auto pageHeight = argument2.value().isUndefined() ? 600 : convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument2.value());
10357 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10358 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLLong>(*lexicalGlobalObject, throwScope, impl.pageNumber(*element, WTFMove(pageWidth), WTFMove(pageHeight)))));
10359}
10360
10361JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageNumber, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10362{
10363 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pageNumberBody>(*lexicalGlobalObject, *callFrame, "pageNumber");
10364}
10365
10366static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_shortcutIconURLsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10367{
10368 auto& vm = JSC::getVM(lexicalGlobalObject);
10369 auto throwScope = DECLARE_THROW_SCOPE(vm);
10370 UNUSED_PARAM(throwScope);
10371 UNUSED_PARAM(callFrame);
10372 auto& impl = castedThis->wrapped();
10373 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.shortcutIconURLs())));
10374}
10375
10376JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_shortcutIconURLs, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10377{
10378 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_shortcutIconURLsBody>(*lexicalGlobalObject, *callFrame, "shortcutIconURLs");
10379}
10380
10381static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_numberOfPagesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10382{
10383 auto& vm = JSC::getVM(lexicalGlobalObject);
10384 auto throwScope = DECLARE_THROW_SCOPE(vm);
10385 UNUSED_PARAM(throwScope);
10386 UNUSED_PARAM(callFrame);
10387 auto& impl = castedThis->wrapped();
10388 EnsureStillAliveScope argument0 = callFrame->argument(0);
10389 auto pageWidthInPixels = argument0.value().isUndefined() ? 800 : convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
10390 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10391 EnsureStillAliveScope argument1 = callFrame->argument(1);
10392 auto pageHeightInPixels = argument1.value().isUndefined() ? 600 : convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
10393 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10394 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLLong>(*lexicalGlobalObject, throwScope, impl.numberOfPages(WTFMove(pageWidthInPixels), WTFMove(pageHeightInPixels)))));
10395}
10396
10397JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfPages, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10398{
10399 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_numberOfPagesBody>(*lexicalGlobalObject, *callFrame, "numberOfPages");
10400}
10401
10402static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pagePropertyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10403{
10404 auto& vm = JSC::getVM(lexicalGlobalObject);
10405 auto throwScope = DECLARE_THROW_SCOPE(vm);
10406 UNUSED_PARAM(throwScope);
10407 UNUSED_PARAM(callFrame);
10408 auto& impl = castedThis->wrapped();
10409 if (UNLIKELY(callFrame->argumentCount() < 2))
10410 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10411 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10412 auto propertyName = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
10413 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10414 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
10415 auto pageNumber = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
10416 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10417 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.pageProperty(WTFMove(propertyName), WTFMove(pageNumber)))));
10418}
10419
10420JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageProperty, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10421{
10422 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pagePropertyBody>(*lexicalGlobalObject, *callFrame, "pageProperty");
10423}
10424
10425static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pageSizeAndMarginsInPixelsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10426{
10427 auto& vm = JSC::getVM(lexicalGlobalObject);
10428 auto throwScope = DECLARE_THROW_SCOPE(vm);
10429 UNUSED_PARAM(throwScope);
10430 UNUSED_PARAM(callFrame);
10431 auto& impl = castedThis->wrapped();
10432 if (UNLIKELY(callFrame->argumentCount() < 7))
10433 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10434 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10435 auto pageIndex = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
10436 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10437 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
10438 auto width = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
10439 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10440 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
10441 auto height = convert<IDLLong>(*lexicalGlobalObject, argument2.value());
10442 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10443 EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
10444 auto marginTop = convert<IDLLong>(*lexicalGlobalObject, argument3.value());
10445 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10446 EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
10447 auto marginRight = convert<IDLLong>(*lexicalGlobalObject, argument4.value());
10448 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10449 EnsureStillAliveScope argument5 = callFrame->uncheckedArgument(5);
10450 auto marginBottom = convert<IDLLong>(*lexicalGlobalObject, argument5.value());
10451 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10452 EnsureStillAliveScope argument6 = callFrame->uncheckedArgument(6);
10453 auto marginLeft = convert<IDLLong>(*lexicalGlobalObject, argument6.value());
10454 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10455 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.pageSizeAndMarginsInPixels(WTFMove(pageIndex), WTFMove(width), WTFMove(height), WTFMove(marginTop), WTFMove(marginRight), WTFMove(marginBottom), WTFMove(marginLeft)))));
10456}
10457
10458JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageSizeAndMarginsInPixels, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10459{
10460 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pageSizeAndMarginsInPixelsBody>(*lexicalGlobalObject, *callFrame, "pageSizeAndMarginsInPixels");
10461}
10462
10463static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setPageScaleFactorBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10464{
10465 auto& vm = JSC::getVM(lexicalGlobalObject);
10466 auto throwScope = DECLARE_THROW_SCOPE(vm);
10467 UNUSED_PARAM(throwScope);
10468 UNUSED_PARAM(callFrame);
10469 auto& impl = castedThis->wrapped();
10470 if (UNLIKELY(callFrame->argumentCount() < 3))
10471 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10472 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10473 auto scaleFactor = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument0.value());
10474 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10475 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
10476 auto x = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
10477 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10478 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
10479 auto y = convert<IDLLong>(*lexicalGlobalObject, argument2.value());
10480 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10481 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setPageScaleFactor(WTFMove(scaleFactor), WTFMove(x), WTFMove(y)); })));
10482}
10483
10484JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageScaleFactor, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10485{
10486 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setPageScaleFactorBody>(*lexicalGlobalObject, *callFrame, "setPageScaleFactor");
10487}
10488
10489static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pageScaleFactorBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10490{
10491 auto& vm = JSC::getVM(lexicalGlobalObject);
10492 auto throwScope = DECLARE_THROW_SCOPE(vm);
10493 UNUSED_PARAM(throwScope);
10494 UNUSED_PARAM(callFrame);
10495 auto& impl = castedThis->wrapped();
10496 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLFloat>(*lexicalGlobalObject, throwScope, impl.pageScaleFactor())));
10497}
10498
10499JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageScaleFactor, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10500{
10501 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pageScaleFactorBody>(*lexicalGlobalObject, *callFrame, "pageScaleFactor");
10502}
10503
10504static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setPageZoomFactorBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10505{
10506 auto& vm = JSC::getVM(lexicalGlobalObject);
10507 auto throwScope = DECLARE_THROW_SCOPE(vm);
10508 UNUSED_PARAM(throwScope);
10509 UNUSED_PARAM(callFrame);
10510 auto& impl = castedThis->wrapped();
10511 if (UNLIKELY(callFrame->argumentCount() < 1))
10512 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10513 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10514 auto zoomFactor = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument0.value());
10515 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10516 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setPageZoomFactor(WTFMove(zoomFactor)); })));
10517}
10518
10519JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageZoomFactor, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10520{
10521 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setPageZoomFactorBody>(*lexicalGlobalObject, *callFrame, "setPageZoomFactor");
10522}
10523
10524static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setTextZoomFactorBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10525{
10526 auto& vm = JSC::getVM(lexicalGlobalObject);
10527 auto throwScope = DECLARE_THROW_SCOPE(vm);
10528 UNUSED_PARAM(throwScope);
10529 UNUSED_PARAM(callFrame);
10530 auto& impl = castedThis->wrapped();
10531 if (UNLIKELY(callFrame->argumentCount() < 1))
10532 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10533 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10534 auto zoomFactor = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument0.value());
10535 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10536 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setTextZoomFactor(WTFMove(zoomFactor)); })));
10537}
10538
10539JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setTextZoomFactor, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10540{
10541 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setTextZoomFactorBody>(*lexicalGlobalObject, *callFrame, "setTextZoomFactor");
10542}
10543
10544static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setUseFixedLayoutBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10545{
10546 auto& vm = JSC::getVM(lexicalGlobalObject);
10547 auto throwScope = DECLARE_THROW_SCOPE(vm);
10548 UNUSED_PARAM(throwScope);
10549 UNUSED_PARAM(callFrame);
10550 auto& impl = castedThis->wrapped();
10551 if (UNLIKELY(callFrame->argumentCount() < 1))
10552 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10553 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10554 auto useFixedLayout = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
10555 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10556 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setUseFixedLayout(WTFMove(useFixedLayout)); })));
10557}
10558
10559JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUseFixedLayout, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10560{
10561 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setUseFixedLayoutBody>(*lexicalGlobalObject, *callFrame, "setUseFixedLayout");
10562}
10563
10564static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setFixedLayoutSizeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10565{
10566 auto& vm = JSC::getVM(lexicalGlobalObject);
10567 auto throwScope = DECLARE_THROW_SCOPE(vm);
10568 UNUSED_PARAM(throwScope);
10569 UNUSED_PARAM(callFrame);
10570 auto& impl = castedThis->wrapped();
10571 if (UNLIKELY(callFrame->argumentCount() < 2))
10572 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10573 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10574 auto width = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
10575 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10576 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
10577 auto height = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
10578 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10579 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setFixedLayoutSize(WTFMove(width), WTFMove(height)); })));
10580}
10581
10582JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setFixedLayoutSize, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10583{
10584 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setFixedLayoutSizeBody>(*lexicalGlobalObject, *callFrame, "setFixedLayoutSize");
10585}
10586
10587static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setPrintingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10588{
10589 auto& vm = JSC::getVM(lexicalGlobalObject);
10590 auto throwScope = DECLARE_THROW_SCOPE(vm);
10591 UNUSED_PARAM(throwScope);
10592 UNUSED_PARAM(callFrame);
10593 auto& impl = castedThis->wrapped();
10594 if (UNLIKELY(callFrame->argumentCount() < 2))
10595 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10596 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10597 auto width = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
10598 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10599 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
10600 auto height = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
10601 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10602 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setPrinting(WTFMove(width), WTFMove(height)); })));
10603}
10604
10605JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPrinting, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10606{
10607 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setPrintingBody>(*lexicalGlobalObject, *callFrame, "setPrinting");
10608}
10609
10610static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setViewExposedRectBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10611{
10612 auto& vm = JSC::getVM(lexicalGlobalObject);
10613 auto throwScope = DECLARE_THROW_SCOPE(vm);
10614 UNUSED_PARAM(throwScope);
10615 UNUSED_PARAM(callFrame);
10616 auto& impl = castedThis->wrapped();
10617 if (UNLIKELY(callFrame->argumentCount() < 4))
10618 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10619 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10620 auto x = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument0.value());
10621 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10622 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
10623 auto y = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument1.value());
10624 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10625 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
10626 auto width = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument2.value());
10627 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10628 EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
10629 auto height = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument3.value());
10630 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10631 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setViewExposedRect(WTFMove(x), WTFMove(y), WTFMove(width), WTFMove(height)); })));
10632}
10633
10634JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setViewExposedRect, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10635{
10636 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setViewExposedRectBody>(*lexicalGlobalObject, *callFrame, "setViewExposedRect");
10637}
10638
10639static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setHeaderHeightBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10640{
10641 auto& vm = JSC::getVM(lexicalGlobalObject);
10642 auto throwScope = DECLARE_THROW_SCOPE(vm);
10643 UNUSED_PARAM(throwScope);
10644 UNUSED_PARAM(callFrame);
10645 auto& impl = castedThis->wrapped();
10646 if (UNLIKELY(callFrame->argumentCount() < 1))
10647 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10648 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10649 auto height = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument0.value());
10650 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10651 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setHeaderHeight(WTFMove(height)); })));
10652}
10653
10654JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setHeaderHeight, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10655{
10656 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setHeaderHeightBody>(*lexicalGlobalObject, *callFrame, "setHeaderHeight");
10657}
10658
10659static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setFooterHeightBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10660{
10661 auto& vm = JSC::getVM(lexicalGlobalObject);
10662 auto throwScope = DECLARE_THROW_SCOPE(vm);
10663 UNUSED_PARAM(throwScope);
10664 UNUSED_PARAM(callFrame);
10665 auto& impl = castedThis->wrapped();
10666 if (UNLIKELY(callFrame->argumentCount() < 1))
10667 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10668 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10669 auto height = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument0.value());
10670 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10671 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setFooterHeight(WTFMove(height)); })));
10672}
10673
10674JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setFooterHeight, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10675{
10676 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setFooterHeightBody>(*lexicalGlobalObject, *callFrame, "setFooterHeight");
10677}
10678
10679static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setTopContentInsetBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10680{
10681 auto& vm = JSC::getVM(lexicalGlobalObject);
10682 auto throwScope = DECLARE_THROW_SCOPE(vm);
10683 UNUSED_PARAM(throwScope);
10684 UNUSED_PARAM(callFrame);
10685 auto& impl = castedThis->wrapped();
10686 if (UNLIKELY(callFrame->argumentCount() < 1))
10687 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10688 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10689 auto contentInset = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument0.value());
10690 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10691 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setTopContentInset(WTFMove(contentInset)); })));
10692}
10693
10694JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setTopContentInset, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10695{
10696 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setTopContentInsetBody>(*lexicalGlobalObject, *callFrame, "setTopContentInset");
10697}
10698
10699#if ENABLE(FULLSCREEN_API)
10700static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_webkitWillEnterFullScreenForElementBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10701{
10702 auto& vm = JSC::getVM(lexicalGlobalObject);
10703 auto throwScope = DECLARE_THROW_SCOPE(vm);
10704 UNUSED_PARAM(throwScope);
10705 UNUSED_PARAM(callFrame);
10706 auto& impl = castedThis->wrapped();
10707 if (UNLIKELY(callFrame->argumentCount() < 1))
10708 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10709 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10710 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "webkitWillEnterFullScreenForElement", "Element"); });
10711 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10712 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.webkitWillEnterFullScreenForElement(*element); })));
10713}
10714
10715JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_webkitWillEnterFullScreenForElement, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10716{
10717 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_webkitWillEnterFullScreenForElementBody>(*lexicalGlobalObject, *callFrame, "webkitWillEnterFullScreenForElement");
10718}
10719
10720#endif
10721
10722#if ENABLE(FULLSCREEN_API)
10723static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_webkitDidEnterFullScreenForElementBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10724{
10725 auto& vm = JSC::getVM(lexicalGlobalObject);
10726 auto throwScope = DECLARE_THROW_SCOPE(vm);
10727 UNUSED_PARAM(throwScope);
10728 UNUSED_PARAM(callFrame);
10729 auto& impl = castedThis->wrapped();
10730 if (UNLIKELY(callFrame->argumentCount() < 1))
10731 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10732 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10733 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "webkitDidEnterFullScreenForElement", "Element"); });
10734 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10735 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.webkitDidEnterFullScreenForElement(*element); })));
10736}
10737
10738JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_webkitDidEnterFullScreenForElement, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10739{
10740 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_webkitDidEnterFullScreenForElementBody>(*lexicalGlobalObject, *callFrame, "webkitDidEnterFullScreenForElement");
10741}
10742
10743#endif
10744
10745#if ENABLE(FULLSCREEN_API)
10746static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_webkitWillExitFullScreenForElementBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10747{
10748 auto& vm = JSC::getVM(lexicalGlobalObject);
10749 auto throwScope = DECLARE_THROW_SCOPE(vm);
10750 UNUSED_PARAM(throwScope);
10751 UNUSED_PARAM(callFrame);
10752 auto& impl = castedThis->wrapped();
10753 if (UNLIKELY(callFrame->argumentCount() < 1))
10754 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10755 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10756 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "webkitWillExitFullScreenForElement", "Element"); });
10757 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10758 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.webkitWillExitFullScreenForElement(*element); })));
10759}
10760
10761JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_webkitWillExitFullScreenForElement, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10762{
10763 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_webkitWillExitFullScreenForElementBody>(*lexicalGlobalObject, *callFrame, "webkitWillExitFullScreenForElement");
10764}
10765
10766#endif
10767
10768#if ENABLE(FULLSCREEN_API)
10769static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_webkitDidExitFullScreenForElementBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10770{
10771 auto& vm = JSC::getVM(lexicalGlobalObject);
10772 auto throwScope = DECLARE_THROW_SCOPE(vm);
10773 UNUSED_PARAM(throwScope);
10774 UNUSED_PARAM(callFrame);
10775 auto& impl = castedThis->wrapped();
10776 if (UNLIKELY(callFrame->argumentCount() < 1))
10777 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10778 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10779 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "webkitDidExitFullScreenForElement", "Element"); });
10780 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10781 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.webkitDidExitFullScreenForElement(*element); })));
10782}
10783
10784JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_webkitDidExitFullScreenForElement, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10785{
10786 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_webkitDidExitFullScreenForElementBody>(*lexicalGlobalObject, *callFrame, "webkitDidExitFullScreenForElement");
10787}
10788
10789#endif
10790
10791static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setFullscreenInsetsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10792{
10793 auto& vm = JSC::getVM(lexicalGlobalObject);
10794 auto throwScope = DECLARE_THROW_SCOPE(vm);
10795 UNUSED_PARAM(throwScope);
10796 UNUSED_PARAM(callFrame);
10797 auto& impl = castedThis->wrapped();
10798 if (UNLIKELY(callFrame->argumentCount() < 1))
10799 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10800 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10801 auto insets = convert<IDLDictionary<Internals::FullscreenInsets>>(*lexicalGlobalObject, argument0.value());
10802 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10803 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setFullscreenInsets(WTFMove(insets)); })));
10804}
10805
10806JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setFullscreenInsets, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10807{
10808 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setFullscreenInsetsBody>(*lexicalGlobalObject, *callFrame, "setFullscreenInsets");
10809}
10810
10811static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setFullscreenAutoHideDurationBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10812{
10813 auto& vm = JSC::getVM(lexicalGlobalObject);
10814 auto throwScope = DECLARE_THROW_SCOPE(vm);
10815 UNUSED_PARAM(throwScope);
10816 UNUSED_PARAM(callFrame);
10817 auto& impl = castedThis->wrapped();
10818 if (UNLIKELY(callFrame->argumentCount() < 1))
10819 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10820 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10821 auto duration = convert<IDLDouble>(*lexicalGlobalObject, argument0.value());
10822 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10823 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setFullscreenAutoHideDuration(WTFMove(duration)); })));
10824}
10825
10826JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setFullscreenAutoHideDuration, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10827{
10828 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setFullscreenAutoHideDurationBody>(*lexicalGlobalObject, *callFrame, "setFullscreenAutoHideDuration");
10829}
10830
10831static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setFullscreenControlsHiddenBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10832{
10833 auto& vm = JSC::getVM(lexicalGlobalObject);
10834 auto throwScope = DECLARE_THROW_SCOPE(vm);
10835 UNUSED_PARAM(throwScope);
10836 UNUSED_PARAM(callFrame);
10837 auto& impl = castedThis->wrapped();
10838 if (UNLIKELY(callFrame->argumentCount() < 1))
10839 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10840 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10841 auto hidden = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
10842 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10843 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setFullscreenControlsHidden(WTFMove(hidden)); })));
10844}
10845
10846JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setFullscreenControlsHidden, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10847{
10848 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setFullscreenControlsHiddenBody>(*lexicalGlobalObject, *callFrame, "setFullscreenControlsHidden");
10849}
10850
10851#if ENABLE(VIDEO)
10852static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isChangingPresentationModeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10853{
10854 auto& vm = JSC::getVM(lexicalGlobalObject);
10855 auto throwScope = DECLARE_THROW_SCOPE(vm);
10856 UNUSED_PARAM(throwScope);
10857 UNUSED_PARAM(callFrame);
10858 auto& impl = castedThis->wrapped();
10859 if (UNLIKELY(callFrame->argumentCount() < 1))
10860 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10861 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10862 auto element = convert<IDLInterface<HTMLVideoElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "isChangingPresentationMode", "HTMLVideoElement"); });
10863 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10864 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isChangingPresentationMode(*element))));
10865}
10866
10867JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isChangingPresentationMode, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10868{
10869 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isChangingPresentationModeBody>(*lexicalGlobalObject, *callFrame, "isChangingPresentationMode");
10870}
10871
10872#endif
10873
10874#if ENABLE(VIDEO_PRESENTATION_MODE)
10875static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMockVideoPresentationModeEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10876{
10877 auto& vm = JSC::getVM(lexicalGlobalObject);
10878 auto throwScope = DECLARE_THROW_SCOPE(vm);
10879 UNUSED_PARAM(throwScope);
10880 UNUSED_PARAM(callFrame);
10881 auto& impl = castedThis->wrapped();
10882 if (UNLIKELY(callFrame->argumentCount() < 1))
10883 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10884 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10885 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
10886 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10887 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMockVideoPresentationModeEnabled(WTFMove(enabled)); })));
10888}
10889
10890JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMockVideoPresentationModeEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10891{
10892 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMockVideoPresentationModeEnabledBody>(*lexicalGlobalObject, *callFrame, "setMockVideoPresentationModeEnabled");
10893}
10894
10895#endif
10896
10897static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setApplicationCacheOriginQuotaBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10898{
10899 auto& vm = JSC::getVM(lexicalGlobalObject);
10900 auto throwScope = DECLARE_THROW_SCOPE(vm);
10901 UNUSED_PARAM(throwScope);
10902 UNUSED_PARAM(callFrame);
10903 auto& impl = castedThis->wrapped();
10904 if (UNLIKELY(callFrame->argumentCount() < 1))
10905 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10906 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10907 auto quota = convert<IDLUnsignedLongLong>(*lexicalGlobalObject, argument0.value());
10908 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10909 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setApplicationCacheOriginQuota(WTFMove(quota)); })));
10910}
10911
10912JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setApplicationCacheOriginQuota, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10913{
10914 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setApplicationCacheOriginQuotaBody>(*lexicalGlobalObject, *callFrame, "setApplicationCacheOriginQuota");
10915}
10916
10917static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_registerURLSchemeAsBypassingContentSecurityPolicyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10918{
10919 auto& vm = JSC::getVM(lexicalGlobalObject);
10920 auto throwScope = DECLARE_THROW_SCOPE(vm);
10921 UNUSED_PARAM(throwScope);
10922 UNUSED_PARAM(callFrame);
10923 auto& impl = castedThis->wrapped();
10924 if (UNLIKELY(callFrame->argumentCount() < 1))
10925 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10926 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10927 auto scheme = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
10928 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10929 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.registerURLSchemeAsBypassingContentSecurityPolicy(WTFMove(scheme)); })));
10930}
10931
10932JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_registerURLSchemeAsBypassingContentSecurityPolicy, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10933{
10934 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_registerURLSchemeAsBypassingContentSecurityPolicyBody>(*lexicalGlobalObject, *callFrame, "registerURLSchemeAsBypassingContentSecurityPolicy");
10935}
10936
10937static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_removeURLSchemeRegisteredAsBypassingContentSecurityPolicyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10938{
10939 auto& vm = JSC::getVM(lexicalGlobalObject);
10940 auto throwScope = DECLARE_THROW_SCOPE(vm);
10941 UNUSED_PARAM(throwScope);
10942 UNUSED_PARAM(callFrame);
10943 auto& impl = castedThis->wrapped();
10944 if (UNLIKELY(callFrame->argumentCount() < 1))
10945 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10946 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10947 auto scheme = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
10948 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10949 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.removeURLSchemeRegisteredAsBypassingContentSecurityPolicy(WTFMove(scheme)); })));
10950}
10951
10952JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_removeURLSchemeRegisteredAsBypassingContentSecurityPolicy, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10953{
10954 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_removeURLSchemeRegisteredAsBypassingContentSecurityPolicyBody>(*lexicalGlobalObject, *callFrame, "removeURLSchemeRegisteredAsBypassingContentSecurityPolicy");
10955}
10956
10957static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_registerDefaultPortForProtocolBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10958{
10959 auto& vm = JSC::getVM(lexicalGlobalObject);
10960 auto throwScope = DECLARE_THROW_SCOPE(vm);
10961 UNUSED_PARAM(throwScope);
10962 UNUSED_PARAM(callFrame);
10963 auto& impl = castedThis->wrapped();
10964 if (UNLIKELY(callFrame->argumentCount() < 2))
10965 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
10966 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
10967 auto port = convert<IDLUnsignedShort>(*lexicalGlobalObject, argument0.value());
10968 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10969 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
10970 auto scheme = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
10971 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
10972 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.registerDefaultPortForProtocol(WTFMove(port), WTFMove(scheme)); })));
10973}
10974
10975JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_registerDefaultPortForProtocol, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10976{
10977 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_registerDefaultPortForProtocolBody>(*lexicalGlobalObject, *callFrame, "registerDefaultPortForProtocol");
10978}
10979
10980static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_mallocStatisticsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10981{
10982 auto& vm = JSC::getVM(lexicalGlobalObject);
10983 auto throwScope = DECLARE_THROW_SCOPE(vm);
10984 UNUSED_PARAM(throwScope);
10985 UNUSED_PARAM(callFrame);
10986 auto& impl = castedThis->wrapped();
10987 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<MallocStatistics>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.mallocStatistics())));
10988}
10989
10990JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_mallocStatistics, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
10991{
10992 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_mallocStatisticsBody>(*lexicalGlobalObject, *callFrame, "mallocStatistics");
10993}
10994
10995static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_typeConversionsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
10996{
10997 auto& vm = JSC::getVM(lexicalGlobalObject);
10998 auto throwScope = DECLARE_THROW_SCOPE(vm);
10999 UNUSED_PARAM(throwScope);
11000 UNUSED_PARAM(callFrame);
11001 auto& impl = castedThis->wrapped();
11002 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<TypeConversions>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.typeConversions())));
11003}
11004
11005JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_typeConversions, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11006{
11007 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_typeConversionsBody>(*lexicalGlobalObject, *callFrame, "typeConversions");
11008}
11009
11010static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_memoryInfoBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11011{
11012 auto& vm = JSC::getVM(lexicalGlobalObject);
11013 auto throwScope = DECLARE_THROW_SCOPE(vm);
11014 UNUSED_PARAM(throwScope);
11015 UNUSED_PARAM(callFrame);
11016 auto& impl = castedThis->wrapped();
11017 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<MemoryInfo>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.memoryInfo())));
11018}
11019
11020JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_memoryInfo, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11021{
11022 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_memoryInfoBody>(*lexicalGlobalObject, *callFrame, "memoryInfo");
11023}
11024
11025static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_getReferencedFilePathsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11026{
11027 auto& vm = JSC::getVM(lexicalGlobalObject);
11028 auto throwScope = DECLARE_THROW_SCOPE(vm);
11029 UNUSED_PARAM(throwScope);
11030 UNUSED_PARAM(callFrame);
11031 auto& impl = castedThis->wrapped();
11032 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.getReferencedFilePaths())));
11033}
11034
11035JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_getReferencedFilePaths, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11036{
11037 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_getReferencedFilePathsBody>(*lexicalGlobalObject, *callFrame, "getReferencedFilePaths");
11038}
11039
11040static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_startTrackingRepaintsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11041{
11042 auto& vm = JSC::getVM(lexicalGlobalObject);
11043 auto throwScope = DECLARE_THROW_SCOPE(vm);
11044 UNUSED_PARAM(throwScope);
11045 UNUSED_PARAM(callFrame);
11046 auto& impl = castedThis->wrapped();
11047 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.startTrackingRepaints(); })));
11048}
11049
11050JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_startTrackingRepaints, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11051{
11052 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_startTrackingRepaintsBody>(*lexicalGlobalObject, *callFrame, "startTrackingRepaints");
11053}
11054
11055static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_stopTrackingRepaintsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11056{
11057 auto& vm = JSC::getVM(lexicalGlobalObject);
11058 auto throwScope = DECLARE_THROW_SCOPE(vm);
11059 UNUSED_PARAM(throwScope);
11060 UNUSED_PARAM(callFrame);
11061 auto& impl = castedThis->wrapped();
11062 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.stopTrackingRepaints(); })));
11063}
11064
11065JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_stopTrackingRepaints, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11066{
11067 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_stopTrackingRepaintsBody>(*lexicalGlobalObject, *callFrame, "stopTrackingRepaints");
11068}
11069
11070static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_startTrackingLayerFlushesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11071{
11072 auto& vm = JSC::getVM(lexicalGlobalObject);
11073 auto throwScope = DECLARE_THROW_SCOPE(vm);
11074 UNUSED_PARAM(throwScope);
11075 UNUSED_PARAM(callFrame);
11076 auto& impl = castedThis->wrapped();
11077 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.startTrackingLayerFlushes(); })));
11078}
11079
11080JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_startTrackingLayerFlushes, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11081{
11082 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_startTrackingLayerFlushesBody>(*lexicalGlobalObject, *callFrame, "startTrackingLayerFlushes");
11083}
11084
11085static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_layerFlushCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11086{
11087 auto& vm = JSC::getVM(lexicalGlobalObject);
11088 auto throwScope = DECLARE_THROW_SCOPE(vm);
11089 UNUSED_PARAM(throwScope);
11090 UNUSED_PARAM(callFrame);
11091 auto& impl = castedThis->wrapped();
11092 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.layerFlushCount())));
11093}
11094
11095JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_layerFlushCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11096{
11097 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_layerFlushCountBody>(*lexicalGlobalObject, *callFrame, "layerFlushCount");
11098}
11099
11100static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isTimerThrottledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11101{
11102 auto& vm = JSC::getVM(lexicalGlobalObject);
11103 auto throwScope = DECLARE_THROW_SCOPE(vm);
11104 UNUSED_PARAM(throwScope);
11105 UNUSED_PARAM(callFrame);
11106 auto& impl = castedThis->wrapped();
11107 if (UNLIKELY(callFrame->argumentCount() < 1))
11108 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11109 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11110 auto timerHandle = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
11111 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11112 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isTimerThrottled(WTFMove(timerHandle)))));
11113}
11114
11115JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isTimerThrottled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11116{
11117 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isTimerThrottledBody>(*lexicalGlobalObject, *callFrame, "isTimerThrottled");
11118}
11119
11120static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_requestAnimationFrameThrottlingReasonsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11121{
11122 auto& vm = JSC::getVM(lexicalGlobalObject);
11123 auto throwScope = DECLARE_THROW_SCOPE(vm);
11124 UNUSED_PARAM(throwScope);
11125 UNUSED_PARAM(callFrame);
11126 auto& impl = castedThis->wrapped();
11127 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.requestAnimationFrameThrottlingReasons())));
11128}
11129
11130JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_requestAnimationFrameThrottlingReasons, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11131{
11132 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_requestAnimationFrameThrottlingReasonsBody>(*lexicalGlobalObject, *callFrame, "requestAnimationFrameThrottlingReasons");
11133}
11134
11135static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_areTimersThrottledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11136{
11137 auto& vm = JSC::getVM(lexicalGlobalObject);
11138 auto throwScope = DECLARE_THROW_SCOPE(vm);
11139 UNUSED_PARAM(throwScope);
11140 UNUSED_PARAM(callFrame);
11141 auto& impl = castedThis->wrapped();
11142 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.areTimersThrottled())));
11143}
11144
11145JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_areTimersThrottled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11146{
11147 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_areTimersThrottledBody>(*lexicalGlobalObject, *callFrame, "areTimersThrottled");
11148}
11149
11150static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setLowPowerModeEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11151{
11152 auto& vm = JSC::getVM(lexicalGlobalObject);
11153 auto throwScope = DECLARE_THROW_SCOPE(vm);
11154 UNUSED_PARAM(throwScope);
11155 UNUSED_PARAM(callFrame);
11156 auto& impl = castedThis->wrapped();
11157 if (UNLIKELY(callFrame->argumentCount() < 1))
11158 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11159 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11160 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
11161 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11162 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setLowPowerModeEnabled(WTFMove(enabled)); })));
11163}
11164
11165JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setLowPowerModeEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11166{
11167 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setLowPowerModeEnabledBody>(*lexicalGlobalObject, *callFrame, "setLowPowerModeEnabled");
11168}
11169
11170static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setOutsideViewportThrottlingEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11171{
11172 auto& vm = JSC::getVM(lexicalGlobalObject);
11173 auto throwScope = DECLARE_THROW_SCOPE(vm);
11174 UNUSED_PARAM(throwScope);
11175 UNUSED_PARAM(callFrame);
11176 auto& impl = castedThis->wrapped();
11177 if (UNLIKELY(callFrame->argumentCount() < 1))
11178 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11179 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11180 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
11181 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11182 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setOutsideViewportThrottlingEnabled(WTFMove(enabled)); })));
11183}
11184
11185JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setOutsideViewportThrottlingEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11186{
11187 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setOutsideViewportThrottlingEnabledBody>(*lexicalGlobalObject, *callFrame, "setOutsideViewportThrottlingEnabled");
11188}
11189
11190static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_startTrackingStyleRecalcsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11191{
11192 auto& vm = JSC::getVM(lexicalGlobalObject);
11193 auto throwScope = DECLARE_THROW_SCOPE(vm);
11194 UNUSED_PARAM(throwScope);
11195 UNUSED_PARAM(callFrame);
11196 auto& impl = castedThis->wrapped();
11197 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.startTrackingStyleRecalcs(); })));
11198}
11199
11200JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_startTrackingStyleRecalcs, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11201{
11202 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_startTrackingStyleRecalcsBody>(*lexicalGlobalObject, *callFrame, "startTrackingStyleRecalcs");
11203}
11204
11205static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_styleRecalcCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11206{
11207 auto& vm = JSC::getVM(lexicalGlobalObject);
11208 auto throwScope = DECLARE_THROW_SCOPE(vm);
11209 UNUSED_PARAM(throwScope);
11210 UNUSED_PARAM(callFrame);
11211 auto& impl = castedThis->wrapped();
11212 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.styleRecalcCount())));
11213}
11214
11215JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_styleRecalcCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11216{
11217 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_styleRecalcCountBody>(*lexicalGlobalObject, *callFrame, "styleRecalcCount");
11218}
11219
11220static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_startTrackingCompositingUpdatesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11221{
11222 auto& vm = JSC::getVM(lexicalGlobalObject);
11223 auto throwScope = DECLARE_THROW_SCOPE(vm);
11224 UNUSED_PARAM(throwScope);
11225 UNUSED_PARAM(callFrame);
11226 auto& impl = castedThis->wrapped();
11227 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.startTrackingCompositingUpdates(); })));
11228}
11229
11230JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_startTrackingCompositingUpdates, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11231{
11232 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_startTrackingCompositingUpdatesBody>(*lexicalGlobalObject, *callFrame, "startTrackingCompositingUpdates");
11233}
11234
11235static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_compositingUpdateCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11236{
11237 auto& vm = JSC::getVM(lexicalGlobalObject);
11238 auto throwScope = DECLARE_THROW_SCOPE(vm);
11239 UNUSED_PARAM(throwScope);
11240 UNUSED_PARAM(callFrame);
11241 auto& impl = castedThis->wrapped();
11242 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.compositingUpdateCount())));
11243}
11244
11245JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_compositingUpdateCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11246{
11247 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_compositingUpdateCountBody>(*lexicalGlobalObject, *callFrame, "compositingUpdateCount");
11248}
11249
11250static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_startTrackingRenderingUpdatesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11251{
11252 auto& vm = JSC::getVM(lexicalGlobalObject);
11253 auto throwScope = DECLARE_THROW_SCOPE(vm);
11254 UNUSED_PARAM(throwScope);
11255 UNUSED_PARAM(callFrame);
11256 auto& impl = castedThis->wrapped();
11257 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.startTrackingRenderingUpdates(); })));
11258}
11259
11260JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_startTrackingRenderingUpdates, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11261{
11262 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_startTrackingRenderingUpdatesBody>(*lexicalGlobalObject, *callFrame, "startTrackingRenderingUpdates");
11263}
11264
11265static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_renderingUpdateCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11266{
11267 auto& vm = JSC::getVM(lexicalGlobalObject);
11268 auto throwScope = DECLARE_THROW_SCOPE(vm);
11269 UNUSED_PARAM(throwScope);
11270 UNUSED_PARAM(callFrame);
11271 auto& impl = castedThis->wrapped();
11272 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.renderingUpdateCount())));
11273}
11274
11275JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_renderingUpdateCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11276{
11277 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_renderingUpdateCountBody>(*lexicalGlobalObject, *callFrame, "renderingUpdateCount");
11278}
11279
11280static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_updateLayoutAndStyleForAllFramesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11281{
11282 auto& vm = JSC::getVM(lexicalGlobalObject);
11283 auto throwScope = DECLARE_THROW_SCOPE(vm);
11284 UNUSED_PARAM(throwScope);
11285 UNUSED_PARAM(callFrame);
11286 auto& impl = castedThis->wrapped();
11287 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.updateLayoutAndStyleForAllFrames(); })));
11288}
11289
11290JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_updateLayoutAndStyleForAllFrames, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11291{
11292 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_updateLayoutAndStyleForAllFramesBody>(*lexicalGlobalObject, *callFrame, "updateLayoutAndStyleForAllFrames");
11293}
11294
11295static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasksBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11296{
11297 auto& vm = JSC::getVM(lexicalGlobalObject);
11298 auto throwScope = DECLARE_THROW_SCOPE(vm);
11299 UNUSED_PARAM(throwScope);
11300 UNUSED_PARAM(callFrame);
11301 auto& impl = castedThis->wrapped();
11302 EnsureStillAliveScope argument0 = callFrame->argument(0);
11303 auto node = convert<IDLNullable<IDLInterface<Node>>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "node", "Internals", "updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks", "Node"); });
11304 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11305 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks(WTFMove(node)); })));
11306}
11307
11308JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11309{
11310 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasksBody>(*lexicalGlobalObject, *callFrame, "updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks");
11311}
11312
11313static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_getCurrentCursorInfoBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11314{
11315 auto& vm = JSC::getVM(lexicalGlobalObject);
11316 auto throwScope = DECLARE_THROW_SCOPE(vm);
11317 UNUSED_PARAM(throwScope);
11318 UNUSED_PARAM(callFrame);
11319 auto& impl = castedThis->wrapped();
11320 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.getCurrentCursorInfo())));
11321}
11322
11323JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_getCurrentCursorInfo, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11324{
11325 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_getCurrentCursorInfoBody>(*lexicalGlobalObject, *callFrame, "getCurrentCursorInfo");
11326}
11327
11328static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_markerTextForListItemBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11329{
11330 auto& vm = JSC::getVM(lexicalGlobalObject);
11331 auto throwScope = DECLARE_THROW_SCOPE(vm);
11332 UNUSED_PARAM(throwScope);
11333 UNUSED_PARAM(callFrame);
11334 auto& impl = castedThis->wrapped();
11335 if (UNLIKELY(callFrame->argumentCount() < 1))
11336 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11337 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11338 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "markerTextForListItem", "Element"); });
11339 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11340 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.markerTextForListItem(*element))));
11341}
11342
11343JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_markerTextForListItem, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11344{
11345 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_markerTextForListItemBody>(*lexicalGlobalObject, *callFrame, "markerTextForListItem");
11346}
11347
11348static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_toolTipFromElementBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11349{
11350 auto& vm = JSC::getVM(lexicalGlobalObject);
11351 auto throwScope = DECLARE_THROW_SCOPE(vm);
11352 UNUSED_PARAM(throwScope);
11353 UNUSED_PARAM(callFrame);
11354 auto& impl = castedThis->wrapped();
11355 if (UNLIKELY(callFrame->argumentCount() < 1))
11356 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11357 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11358 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "toolTipFromElement", "Element"); });
11359 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11360 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.toolTipFromElement(*element))));
11361}
11362
11363JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_toolTipFromElement, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11364{
11365 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_toolTipFromElementBody>(*lexicalGlobalObject, *callFrame, "toolTipFromElement");
11366}
11367
11368static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_deserializeBufferBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11369{
11370 auto& vm = JSC::getVM(lexicalGlobalObject);
11371 auto throwScope = DECLARE_THROW_SCOPE(vm);
11372 UNUSED_PARAM(throwScope);
11373 UNUSED_PARAM(callFrame);
11374 auto& impl = castedThis->wrapped();
11375 if (UNLIKELY(callFrame->argumentCount() < 1))
11376 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11377 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11378 auto buffer = convert<IDLArrayBuffer>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "buffer", "Internals", "deserializeBuffer", "ArrayBuffer"); });
11379 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11380 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLSerializedScriptValue<SerializedScriptValue>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.deserializeBuffer(*buffer))));
11381}
11382
11383JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_deserializeBuffer, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11384{
11385 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_deserializeBufferBody>(*lexicalGlobalObject, *callFrame, "deserializeBuffer");
11386}
11387
11388static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_serializeObjectBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11389{
11390 auto& vm = JSC::getVM(lexicalGlobalObject);
11391 auto throwScope = DECLARE_THROW_SCOPE(vm);
11392 UNUSED_PARAM(throwScope);
11393 UNUSED_PARAM(callFrame);
11394 auto& impl = castedThis->wrapped();
11395 if (UNLIKELY(callFrame->argumentCount() < 1))
11396 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11397 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11398 auto object = convert<IDLSerializedScriptValue<SerializedScriptValue>>(*lexicalGlobalObject, argument0.value());
11399 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11400 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLArrayBuffer>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.serializeObject(WTFMove(object)))));
11401}
11402
11403JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_serializeObject, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11404{
11405 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_serializeObjectBody>(*lexicalGlobalObject, *callFrame, "serializeObject");
11406}
11407
11408static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isFromCurrentWorldBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11409{
11410 auto& vm = JSC::getVM(lexicalGlobalObject);
11411 auto throwScope = DECLARE_THROW_SCOPE(vm);
11412 UNUSED_PARAM(throwScope);
11413 UNUSED_PARAM(callFrame);
11414 auto& impl = castedThis->wrapped();
11415 if (UNLIKELY(callFrame->argumentCount() < 1))
11416 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11417 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11418 auto obj = convert<IDLAny>(*lexicalGlobalObject, argument0.value());
11419 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11420 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isFromCurrentWorld(WTFMove(obj)))));
11421}
11422
11423JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isFromCurrentWorld, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11424{
11425 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isFromCurrentWorldBody>(*lexicalGlobalObject, *callFrame, "isFromCurrentWorld");
11426}
11427
11428static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_evaluateInWorldIgnoringExceptionBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11429{
11430 auto& vm = JSC::getVM(lexicalGlobalObject);
11431 auto throwScope = DECLARE_THROW_SCOPE(vm);
11432 UNUSED_PARAM(throwScope);
11433 UNUSED_PARAM(callFrame);
11434 auto& impl = castedThis->wrapped();
11435 if (UNLIKELY(callFrame->argumentCount() < 2))
11436 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11437 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11438 auto name = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
11439 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11440 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
11441 auto source = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
11442 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11443 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLAny>(*lexicalGlobalObject, throwScope, impl.evaluateInWorldIgnoringException(WTFMove(name), WTFMove(source)))));
11444}
11445
11446JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_evaluateInWorldIgnoringException, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11447{
11448 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_evaluateInWorldIgnoringExceptionBody>(*lexicalGlobalObject, *callFrame, "evaluateInWorldIgnoringException");
11449}
11450
11451static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setUsesOverlayScrollbarsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11452{
11453 auto& vm = JSC::getVM(lexicalGlobalObject);
11454 auto throwScope = DECLARE_THROW_SCOPE(vm);
11455 UNUSED_PARAM(throwScope);
11456 UNUSED_PARAM(callFrame);
11457 auto& impl = castedThis->wrapped();
11458 if (UNLIKELY(callFrame->argumentCount() < 1))
11459 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11460 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11461 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
11462 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11463 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setUsesOverlayScrollbars(WTFMove(enabled)); })));
11464}
11465
11466JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUsesOverlayScrollbars, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11467{
11468 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setUsesOverlayScrollbarsBody>(*lexicalGlobalObject, *callFrame, "setUsesOverlayScrollbars");
11469}
11470
11471static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setUsesMockScrollAnimatorBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11472{
11473 auto& vm = JSC::getVM(lexicalGlobalObject);
11474 auto throwScope = DECLARE_THROW_SCOPE(vm);
11475 UNUSED_PARAM(throwScope);
11476 UNUSED_PARAM(callFrame);
11477 auto& impl = castedThis->wrapped();
11478 if (UNLIKELY(callFrame->argumentCount() < 1))
11479 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11480 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11481 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
11482 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11483 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setUsesMockScrollAnimator(WTFMove(enabled)); })));
11484}
11485
11486JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUsesMockScrollAnimator, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11487{
11488 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setUsesMockScrollAnimatorBody>(*lexicalGlobalObject, *callFrame, "setUsesMockScrollAnimator");
11489}
11490
11491static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_forceReloadBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11492{
11493 auto& vm = JSC::getVM(lexicalGlobalObject);
11494 auto throwScope = DECLARE_THROW_SCOPE(vm);
11495 UNUSED_PARAM(throwScope);
11496 UNUSED_PARAM(callFrame);
11497 auto& impl = castedThis->wrapped();
11498 if (UNLIKELY(callFrame->argumentCount() < 1))
11499 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11500 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11501 auto endToEnd = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
11502 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11503 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.forceReload(WTFMove(endToEnd)); })));
11504}
11505
11506JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_forceReload, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11507{
11508 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_forceReloadBody>(*lexicalGlobalObject, *callFrame, "forceReload");
11509}
11510
11511static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_reloadExpiredOnlyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11512{
11513 auto& vm = JSC::getVM(lexicalGlobalObject);
11514 auto throwScope = DECLARE_THROW_SCOPE(vm);
11515 UNUSED_PARAM(throwScope);
11516 UNUSED_PARAM(callFrame);
11517 auto& impl = castedThis->wrapped();
11518 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.reloadExpiredOnly(); })));
11519}
11520
11521JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_reloadExpiredOnly, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11522{
11523 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_reloadExpiredOnlyBody>(*lexicalGlobalObject, *callFrame, "reloadExpiredOnly");
11524}
11525
11526static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_enableFixedWidthAutoSizeModeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11527{
11528 auto& vm = JSC::getVM(lexicalGlobalObject);
11529 auto throwScope = DECLARE_THROW_SCOPE(vm);
11530 UNUSED_PARAM(throwScope);
11531 UNUSED_PARAM(callFrame);
11532 auto& impl = castedThis->wrapped();
11533 if (UNLIKELY(callFrame->argumentCount() < 3))
11534 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11535 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11536 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
11537 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11538 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
11539 auto width = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
11540 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11541 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
11542 auto height = convert<IDLLong>(*lexicalGlobalObject, argument2.value());
11543 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11544 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.enableFixedWidthAutoSizeMode(WTFMove(enabled), WTFMove(width), WTFMove(height)); })));
11545}
11546
11547JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_enableFixedWidthAutoSizeMode, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11548{
11549 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_enableFixedWidthAutoSizeModeBody>(*lexicalGlobalObject, *callFrame, "enableFixedWidthAutoSizeMode");
11550}
11551
11552static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_enableSizeToContentAutoSizeModeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11553{
11554 auto& vm = JSC::getVM(lexicalGlobalObject);
11555 auto throwScope = DECLARE_THROW_SCOPE(vm);
11556 UNUSED_PARAM(throwScope);
11557 UNUSED_PARAM(callFrame);
11558 auto& impl = castedThis->wrapped();
11559 if (UNLIKELY(callFrame->argumentCount() < 3))
11560 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11561 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11562 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
11563 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11564 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
11565 auto width = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
11566 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11567 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
11568 auto height = convert<IDLLong>(*lexicalGlobalObject, argument2.value());
11569 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11570 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.enableSizeToContentAutoSizeMode(WTFMove(enabled), WTFMove(width), WTFMove(height)); })));
11571}
11572
11573JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_enableSizeToContentAutoSizeMode, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11574{
11575 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_enableSizeToContentAutoSizeModeBody>(*lexicalGlobalObject, *callFrame, "enableSizeToContentAutoSizeMode");
11576}
11577
11578#if ENABLE(VIDEO)
11579static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_mediaResponseSourcesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11580{
11581 auto& vm = JSC::getVM(lexicalGlobalObject);
11582 auto throwScope = DECLARE_THROW_SCOPE(vm);
11583 UNUSED_PARAM(throwScope);
11584 UNUSED_PARAM(callFrame);
11585 auto& impl = castedThis->wrapped();
11586 if (UNLIKELY(callFrame->argumentCount() < 1))
11587 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11588 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11589 auto media = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "media", "Internals", "mediaResponseSources", "HTMLMediaElement"); });
11590 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11591 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.mediaResponseSources(*media))));
11592}
11593
11594JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaResponseSources, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11595{
11596 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_mediaResponseSourcesBody>(*lexicalGlobalObject, *callFrame, "mediaResponseSources");
11597}
11598
11599#endif
11600
11601#if ENABLE(VIDEO)
11602static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_mediaResponseContentRangesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11603{
11604 auto& vm = JSC::getVM(lexicalGlobalObject);
11605 auto throwScope = DECLARE_THROW_SCOPE(vm);
11606 UNUSED_PARAM(throwScope);
11607 UNUSED_PARAM(callFrame);
11608 auto& impl = castedThis->wrapped();
11609 if (UNLIKELY(callFrame->argumentCount() < 1))
11610 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11611 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11612 auto media = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "media", "Internals", "mediaResponseContentRanges", "HTMLMediaElement"); });
11613 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11614 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.mediaResponseContentRanges(*media))));
11615}
11616
11617JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaResponseContentRanges, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11618{
11619 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_mediaResponseContentRangesBody>(*lexicalGlobalObject, *callFrame, "mediaResponseContentRanges");
11620}
11621
11622#endif
11623
11624#if ENABLE(VIDEO)
11625static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_simulateAudioInterruptionBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11626{
11627 auto& vm = JSC::getVM(lexicalGlobalObject);
11628 auto throwScope = DECLARE_THROW_SCOPE(vm);
11629 UNUSED_PARAM(throwScope);
11630 UNUSED_PARAM(callFrame);
11631 auto& impl = castedThis->wrapped();
11632 if (UNLIKELY(callFrame->argumentCount() < 1))
11633 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11634 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11635 auto element = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "simulateAudioInterruption", "HTMLMediaElement"); });
11636 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11637 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.simulateAudioInterruption(*element); })));
11638}
11639
11640JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_simulateAudioInterruption, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11641{
11642 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_simulateAudioInterruptionBody>(*lexicalGlobalObject, *callFrame, "simulateAudioInterruption");
11643}
11644
11645#endif
11646
11647#if ENABLE(VIDEO)
11648static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_mediaElementHasCharacteristicBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11649{
11650 auto& vm = JSC::getVM(lexicalGlobalObject);
11651 auto throwScope = DECLARE_THROW_SCOPE(vm);
11652 UNUSED_PARAM(throwScope);
11653 UNUSED_PARAM(callFrame);
11654 auto& impl = castedThis->wrapped();
11655 if (UNLIKELY(callFrame->argumentCount() < 2))
11656 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11657 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11658 auto element = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "mediaElementHasCharacteristic", "HTMLMediaElement"); });
11659 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11660 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
11661 auto characteristic = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
11662 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11663 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.mediaElementHasCharacteristic(*element, WTFMove(characteristic)))));
11664}
11665
11666JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaElementHasCharacteristic, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11667{
11668 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_mediaElementHasCharacteristicBody>(*lexicalGlobalObject, *callFrame, "mediaElementHasCharacteristic");
11669}
11670
11671#endif
11672
11673#if ENABLE(VIDEO)
11674static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_beginSimulatedHDCPErrorBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11675{
11676 auto& vm = JSC::getVM(lexicalGlobalObject);
11677 auto throwScope = DECLARE_THROW_SCOPE(vm);
11678 UNUSED_PARAM(throwScope);
11679 UNUSED_PARAM(callFrame);
11680 auto& impl = castedThis->wrapped();
11681 if (UNLIKELY(callFrame->argumentCount() < 1))
11682 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11683 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11684 auto media = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "media", "Internals", "beginSimulatedHDCPError", "HTMLMediaElement"); });
11685 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11686 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.beginSimulatedHDCPError(*media); })));
11687}
11688
11689JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_beginSimulatedHDCPError, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11690{
11691 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_beginSimulatedHDCPErrorBody>(*lexicalGlobalObject, *callFrame, "beginSimulatedHDCPError");
11692}
11693
11694#endif
11695
11696#if ENABLE(VIDEO)
11697static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_endSimulatedHDCPErrorBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11698{
11699 auto& vm = JSC::getVM(lexicalGlobalObject);
11700 auto throwScope = DECLARE_THROW_SCOPE(vm);
11701 UNUSED_PARAM(throwScope);
11702 UNUSED_PARAM(callFrame);
11703 auto& impl = castedThis->wrapped();
11704 if (UNLIKELY(callFrame->argumentCount() < 1))
11705 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11706 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11707 auto media = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "media", "Internals", "endSimulatedHDCPError", "HTMLMediaElement"); });
11708 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11709 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.endSimulatedHDCPError(*media); })));
11710}
11711
11712JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_endSimulatedHDCPError, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11713{
11714 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_endSimulatedHDCPErrorBody>(*lexicalGlobalObject, *callFrame, "endSimulatedHDCPError");
11715}
11716
11717#endif
11718
11719#if ENABLE(VIDEO)
11720static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_elementShouldBufferDataBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11721{
11722 auto& vm = JSC::getVM(lexicalGlobalObject);
11723 auto throwScope = DECLARE_THROW_SCOPE(vm);
11724 UNUSED_PARAM(throwScope);
11725 UNUSED_PARAM(callFrame);
11726 auto& impl = castedThis->wrapped();
11727 if (UNLIKELY(callFrame->argumentCount() < 1))
11728 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11729 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11730 auto media = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "media", "Internals", "elementShouldBufferData", "HTMLMediaElement"); });
11731 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11732 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.elementShouldBufferData(*media))));
11733}
11734
11735JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_elementShouldBufferData, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11736{
11737 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_elementShouldBufferDataBody>(*lexicalGlobalObject, *callFrame, "elementShouldBufferData");
11738}
11739
11740#endif
11741
11742#if ENABLE(VIDEO)
11743static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_elementBufferingPolicyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11744{
11745 auto& vm = JSC::getVM(lexicalGlobalObject);
11746 auto throwScope = DECLARE_THROW_SCOPE(vm);
11747 UNUSED_PARAM(throwScope);
11748 UNUSED_PARAM(callFrame);
11749 auto& impl = castedThis->wrapped();
11750 if (UNLIKELY(callFrame->argumentCount() < 1))
11751 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11752 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11753 auto media = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "media", "Internals", "elementBufferingPolicy", "HTMLMediaElement"); });
11754 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11755 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.elementBufferingPolicy(*media))));
11756}
11757
11758JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_elementBufferingPolicy, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11759{
11760 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_elementBufferingPolicyBody>(*lexicalGlobalObject, *callFrame, "elementBufferingPolicy");
11761}
11762
11763#endif
11764
11765#if ENABLE(VIDEO)
11766static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_privatePlayerVolumeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11767{
11768 auto& vm = JSC::getVM(lexicalGlobalObject);
11769 auto throwScope = DECLARE_THROW_SCOPE(vm);
11770 UNUSED_PARAM(throwScope);
11771 UNUSED_PARAM(callFrame);
11772 auto& impl = castedThis->wrapped();
11773 if (UNLIKELY(callFrame->argumentCount() < 1))
11774 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11775 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11776 auto media = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "media", "Internals", "privatePlayerVolume", "HTMLMediaElement"); });
11777 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11778 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.privatePlayerVolume(*media))));
11779}
11780
11781JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_privatePlayerVolume, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11782{
11783 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_privatePlayerVolumeBody>(*lexicalGlobalObject, *callFrame, "privatePlayerVolume");
11784}
11785
11786#endif
11787
11788#if ENABLE(VIDEO)
11789static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_privatePlayerMutedBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11790{
11791 auto& vm = JSC::getVM(lexicalGlobalObject);
11792 auto throwScope = DECLARE_THROW_SCOPE(vm);
11793 UNUSED_PARAM(throwScope);
11794 UNUSED_PARAM(callFrame);
11795 auto& impl = castedThis->wrapped();
11796 if (UNLIKELY(callFrame->argumentCount() < 1))
11797 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11798 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11799 auto media = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "media", "Internals", "privatePlayerMuted", "HTMLMediaElement"); });
11800 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11801 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.privatePlayerMuted(*media))));
11802}
11803
11804JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_privatePlayerMuted, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11805{
11806 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_privatePlayerMutedBody>(*lexicalGlobalObject, *callFrame, "privatePlayerMuted");
11807}
11808
11809#endif
11810
11811#if ENABLE(VIDEO)
11812static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isMediaElementHiddenBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11813{
11814 auto& vm = JSC::getVM(lexicalGlobalObject);
11815 auto throwScope = DECLARE_THROW_SCOPE(vm);
11816 UNUSED_PARAM(throwScope);
11817 UNUSED_PARAM(callFrame);
11818 auto& impl = castedThis->wrapped();
11819 if (UNLIKELY(callFrame->argumentCount() < 1))
11820 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11821 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11822 auto media = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "media", "Internals", "isMediaElementHidden", "HTMLMediaElement"); });
11823 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11824 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isMediaElementHidden(*media))));
11825}
11826
11827JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isMediaElementHidden, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11828{
11829 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isMediaElementHiddenBody>(*lexicalGlobalObject, *callFrame, "isMediaElementHidden");
11830}
11831
11832#endif
11833
11834#if ENABLE(VIDEO)
11835static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setOverridePreferredDynamicRangeModeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11836{
11837 auto& vm = JSC::getVM(lexicalGlobalObject);
11838 auto throwScope = DECLARE_THROW_SCOPE(vm);
11839 UNUSED_PARAM(throwScope);
11840 UNUSED_PARAM(callFrame);
11841 auto& impl = castedThis->wrapped();
11842 if (UNLIKELY(callFrame->argumentCount() < 2))
11843 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11844 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11845 auto media = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "media", "Internals", "setOverridePreferredDynamicRangeMode", "HTMLMediaElement"); });
11846 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11847 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
11848 auto mode = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
11849 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11850 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setOverridePreferredDynamicRangeMode(*media, WTFMove(mode)); })));
11851}
11852
11853JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setOverridePreferredDynamicRangeMode, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11854{
11855 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setOverridePreferredDynamicRangeModeBody>(*lexicalGlobalObject, *callFrame, "setOverridePreferredDynamicRangeMode");
11856}
11857
11858#endif
11859
11860static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setIsPlayingToBluetoothOverrideBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11861{
11862 auto& vm = JSC::getVM(lexicalGlobalObject);
11863 auto throwScope = DECLARE_THROW_SCOPE(vm);
11864 UNUSED_PARAM(throwScope);
11865 UNUSED_PARAM(callFrame);
11866 auto& impl = castedThis->wrapped();
11867 EnsureStillAliveScope argument0 = callFrame->argument(0);
11868 auto isPlaying = argument0.value().isUndefined() ? std::nullopt : convert<IDLNullable<IDLBoolean>>(*lexicalGlobalObject, argument0.value());
11869 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11870 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setIsPlayingToBluetoothOverride(WTFMove(isPlaying)); })));
11871}
11872
11873JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setIsPlayingToBluetoothOverride, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11874{
11875 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setIsPlayingToBluetoothOverrideBody>(*lexicalGlobalObject, *callFrame, "setIsPlayingToBluetoothOverride");
11876}
11877
11878#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
11879static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_initializeMockCDMBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11880{
11881 auto& vm = JSC::getVM(lexicalGlobalObject);
11882 auto throwScope = DECLARE_THROW_SCOPE(vm);
11883 UNUSED_PARAM(throwScope);
11884 UNUSED_PARAM(callFrame);
11885 auto& impl = castedThis->wrapped();
11886 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.initializeMockCDM(); })));
11887}
11888
11889JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_initializeMockCDM, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11890{
11891 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_initializeMockCDMBody>(*lexicalGlobalObject, *callFrame, "initializeMockCDM");
11892}
11893
11894#endif
11895
11896#if ENABLE(ENCRYPTED_MEDIA)
11897static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_registerMockCDMBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11898{
11899 auto& vm = JSC::getVM(lexicalGlobalObject);
11900 auto throwScope = DECLARE_THROW_SCOPE(vm);
11901 UNUSED_PARAM(throwScope);
11902 UNUSED_PARAM(callFrame);
11903 auto& impl = castedThis->wrapped();
11904 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<MockCDMFactory>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.registerMockCDM())));
11905}
11906
11907JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_registerMockCDM, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11908{
11909 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_registerMockCDMBody>(*lexicalGlobalObject, *callFrame, "registerMockCDM");
11910}
11911
11912#endif
11913
11914static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_enableMockMediaCapabilitiesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11915{
11916 auto& vm = JSC::getVM(lexicalGlobalObject);
11917 auto throwScope = DECLARE_THROW_SCOPE(vm);
11918 UNUSED_PARAM(throwScope);
11919 UNUSED_PARAM(callFrame);
11920 auto& impl = castedThis->wrapped();
11921 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.enableMockMediaCapabilities(); })));
11922}
11923
11924JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_enableMockMediaCapabilities, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11925{
11926 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_enableMockMediaCapabilitiesBody>(*lexicalGlobalObject, *callFrame, "enableMockMediaCapabilities");
11927}
11928
11929#if ENABLE(SPEECH_SYNTHESIS)
11930static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_enableMockSpeechSynthesizerBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11931{
11932 auto& vm = JSC::getVM(lexicalGlobalObject);
11933 auto throwScope = DECLARE_THROW_SCOPE(vm);
11934 UNUSED_PARAM(throwScope);
11935 UNUSED_PARAM(callFrame);
11936 auto& impl = castedThis->wrapped();
11937 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.enableMockSpeechSynthesizer(); })));
11938}
11939
11940JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_enableMockSpeechSynthesizer, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11941{
11942 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_enableMockSpeechSynthesizerBody>(*lexicalGlobalObject, *callFrame, "enableMockSpeechSynthesizer");
11943}
11944
11945#endif
11946
11947static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_getImageSourceURLBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11948{
11949 auto& vm = JSC::getVM(lexicalGlobalObject);
11950 auto throwScope = DECLARE_THROW_SCOPE(vm);
11951 UNUSED_PARAM(throwScope);
11952 UNUSED_PARAM(callFrame);
11953 auto& impl = castedThis->wrapped();
11954 if (UNLIKELY(callFrame->argumentCount() < 1))
11955 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11956 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11957 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "getImageSourceURL", "Element"); });
11958 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11959 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.getImageSourceURL(*element))));
11960}
11961
11962JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_getImageSourceURL, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11963{
11964 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_getImageSourceURLBody>(*lexicalGlobalObject, *callFrame, "getImageSourceURL");
11965}
11966
11967#if ENABLE(VIDEO)
11968static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_captionsStyleSheetOverrideBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11969{
11970 auto& vm = JSC::getVM(lexicalGlobalObject);
11971 auto throwScope = DECLARE_THROW_SCOPE(vm);
11972 UNUSED_PARAM(throwScope);
11973 UNUSED_PARAM(callFrame);
11974 auto& impl = castedThis->wrapped();
11975 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.captionsStyleSheetOverride())));
11976}
11977
11978JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_captionsStyleSheetOverride, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
11979{
11980 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_captionsStyleSheetOverrideBody>(*lexicalGlobalObject, *callFrame, "captionsStyleSheetOverride");
11981}
11982
11983#endif
11984
11985#if ENABLE(VIDEO)
11986static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setCaptionsStyleSheetOverrideBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
11987{
11988 auto& vm = JSC::getVM(lexicalGlobalObject);
11989 auto throwScope = DECLARE_THROW_SCOPE(vm);
11990 UNUSED_PARAM(throwScope);
11991 UNUSED_PARAM(callFrame);
11992 auto& impl = castedThis->wrapped();
11993 if (UNLIKELY(callFrame->argumentCount() < 1))
11994 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
11995 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
11996 auto override = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
11997 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
11998 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setCaptionsStyleSheetOverride(WTFMove(override)); })));
11999}
12000
12001JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setCaptionsStyleSheetOverride, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12002{
12003 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setCaptionsStyleSheetOverrideBody>(*lexicalGlobalObject, *callFrame, "setCaptionsStyleSheetOverride");
12004}
12005
12006#endif
12007
12008#if ENABLE(VIDEO)
12009static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setPrimaryAudioTrackLanguageOverrideBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12010{
12011 auto& vm = JSC::getVM(lexicalGlobalObject);
12012 auto throwScope = DECLARE_THROW_SCOPE(vm);
12013 UNUSED_PARAM(throwScope);
12014 UNUSED_PARAM(callFrame);
12015 auto& impl = castedThis->wrapped();
12016 if (UNLIKELY(callFrame->argumentCount() < 1))
12017 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12018 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12019 auto language = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
12020 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12021 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setPrimaryAudioTrackLanguageOverride(WTFMove(language)); })));
12022}
12023
12024JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPrimaryAudioTrackLanguageOverride, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12025{
12026 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setPrimaryAudioTrackLanguageOverrideBody>(*lexicalGlobalObject, *callFrame, "setPrimaryAudioTrackLanguageOverride");
12027}
12028
12029#endif
12030
12031#if ENABLE(VIDEO)
12032static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setCaptionDisplayModeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12033{
12034 auto& vm = JSC::getVM(lexicalGlobalObject);
12035 auto throwScope = DECLARE_THROW_SCOPE(vm);
12036 UNUSED_PARAM(throwScope);
12037 UNUSED_PARAM(callFrame);
12038 auto& impl = castedThis->wrapped();
12039 if (UNLIKELY(callFrame->argumentCount() < 1))
12040 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12041 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12042 auto mode = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
12043 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12044 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setCaptionDisplayMode(WTFMove(mode)); })));
12045}
12046
12047JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setCaptionDisplayMode, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12048{
12049 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setCaptionDisplayModeBody>(*lexicalGlobalObject, *callFrame, "setCaptionDisplayMode");
12050}
12051
12052#endif
12053
12054#if ENABLE(VIDEO)
12055static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_createGenericCueBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12056{
12057 auto& vm = JSC::getVM(lexicalGlobalObject);
12058 auto throwScope = DECLARE_THROW_SCOPE(vm);
12059 UNUSED_PARAM(throwScope);
12060 UNUSED_PARAM(callFrame);
12061 auto& impl = castedThis->wrapped();
12062 if (UNLIKELY(callFrame->argumentCount() < 3))
12063 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12064 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12065 auto startTime = convert<IDLDouble>(*lexicalGlobalObject, argument0.value());
12066 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12067 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
12068 auto endTime = convert<IDLDouble>(*lexicalGlobalObject, argument1.value());
12069 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12070 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
12071 auto text = convert<IDLDOMString>(*lexicalGlobalObject, argument2.value());
12072 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12073 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<TextTrackCueGeneric>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.createGenericCue(WTFMove(startTime), WTFMove(endTime), WTFMove(text)))));
12074}
12075
12076JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_createGenericCue, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12077{
12078 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_createGenericCueBody>(*lexicalGlobalObject, *callFrame, "createGenericCue");
12079}
12080
12081#endif
12082
12083#if ENABLE(VIDEO)
12084static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_textTrackBCP47LanguageBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12085{
12086 auto& vm = JSC::getVM(lexicalGlobalObject);
12087 auto throwScope = DECLARE_THROW_SCOPE(vm);
12088 UNUSED_PARAM(throwScope);
12089 UNUSED_PARAM(callFrame);
12090 auto& impl = castedThis->wrapped();
12091 if (UNLIKELY(callFrame->argumentCount() < 1))
12092 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12093 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12094 auto track = convert<IDLInterface<TextTrack>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "track", "Internals", "textTrackBCP47Language", "TextTrack"); });
12095 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12096 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.textTrackBCP47Language(*track))));
12097}
12098
12099JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_textTrackBCP47Language, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12100{
12101 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_textTrackBCP47LanguageBody>(*lexicalGlobalObject, *callFrame, "textTrackBCP47Language");
12102}
12103
12104#endif
12105
12106#if ENABLE(VIDEO)
12107static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_createTimeRangesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12108{
12109 auto& vm = JSC::getVM(lexicalGlobalObject);
12110 auto throwScope = DECLARE_THROW_SCOPE(vm);
12111 UNUSED_PARAM(throwScope);
12112 UNUSED_PARAM(callFrame);
12113 auto& impl = castedThis->wrapped();
12114 if (UNLIKELY(callFrame->argumentCount() < 2))
12115 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12116 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12117 auto startTimes = convert<IDLFloat32Array>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "startTimes", "Internals", "createTimeRanges", "Float32Array"); });
12118 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12119 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
12120 auto endTimes = convert<IDLFloat32Array>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "endTimes", "Internals", "createTimeRanges", "Float32Array"); });
12121 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12122 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<TimeRanges>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.createTimeRanges(startTimes.releaseNonNull(), endTimes.releaseNonNull()))));
12123}
12124
12125JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_createTimeRanges, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12126{
12127 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_createTimeRangesBody>(*lexicalGlobalObject, *callFrame, "createTimeRanges");
12128}
12129
12130#endif
12131
12132#if ENABLE(VIDEO)
12133static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_closestTimeToTimeRangesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12134{
12135 auto& vm = JSC::getVM(lexicalGlobalObject);
12136 auto throwScope = DECLARE_THROW_SCOPE(vm);
12137 UNUSED_PARAM(throwScope);
12138 UNUSED_PARAM(callFrame);
12139 auto& impl = castedThis->wrapped();
12140 if (UNLIKELY(callFrame->argumentCount() < 2))
12141 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12142 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12143 auto time = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
12144 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12145 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
12146 auto ranges = convert<IDLInterface<TimeRanges>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "ranges", "Internals", "closestTimeToTimeRanges", "TimeRanges"); });
12147 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12148 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnrestrictedDouble>(*lexicalGlobalObject, throwScope, impl.closestTimeToTimeRanges(WTFMove(time), *ranges))));
12149}
12150
12151JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_closestTimeToTimeRanges, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12152{
12153 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_closestTimeToTimeRangesBody>(*lexicalGlobalObject, *callFrame, "closestTimeToTimeRanges");
12154}
12155
12156#endif
12157
12158static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isSelectPopupVisibleBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12159{
12160 auto& vm = JSC::getVM(lexicalGlobalObject);
12161 auto throwScope = DECLARE_THROW_SCOPE(vm);
12162 UNUSED_PARAM(throwScope);
12163 UNUSED_PARAM(callFrame);
12164 auto& impl = castedThis->wrapped();
12165 if (UNLIKELY(callFrame->argumentCount() < 1))
12166 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12167 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12168 auto element = convert<IDLInterface<HTMLSelectElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "isSelectPopupVisible", "HTMLSelectElement"); });
12169 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12170 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isSelectPopupVisible(*element))));
12171}
12172
12173JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isSelectPopupVisible, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12174{
12175 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isSelectPopupVisibleBody>(*lexicalGlobalObject, *callFrame, "isSelectPopupVisible");
12176}
12177
12178static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isPluginUnavailabilityIndicatorObscuredBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12179{
12180 auto& vm = JSC::getVM(lexicalGlobalObject);
12181 auto throwScope = DECLARE_THROW_SCOPE(vm);
12182 UNUSED_PARAM(throwScope);
12183 UNUSED_PARAM(callFrame);
12184 auto& impl = castedThis->wrapped();
12185 if (UNLIKELY(callFrame->argumentCount() < 1))
12186 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12187 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12188 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "isPluginUnavailabilityIndicatorObscured", "Element"); });
12189 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12190 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isPluginUnavailabilityIndicatorObscured(*element))));
12191}
12192
12193JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isPluginUnavailabilityIndicatorObscured, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12194{
12195 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isPluginUnavailabilityIndicatorObscuredBody>(*lexicalGlobalObject, *callFrame, "isPluginUnavailabilityIndicatorObscured");
12196}
12197
12198static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_unavailablePluginReplacementTextBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12199{
12200 auto& vm = JSC::getVM(lexicalGlobalObject);
12201 auto throwScope = DECLARE_THROW_SCOPE(vm);
12202 UNUSED_PARAM(throwScope);
12203 UNUSED_PARAM(callFrame);
12204 auto& impl = castedThis->wrapped();
12205 if (UNLIKELY(callFrame->argumentCount() < 1))
12206 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12207 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12208 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "unavailablePluginReplacementText", "Element"); });
12209 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12210 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.unavailablePluginReplacementText(*element))));
12211}
12212
12213JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_unavailablePluginReplacementText, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12214{
12215 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_unavailablePluginReplacementTextBody>(*lexicalGlobalObject, *callFrame, "unavailablePluginReplacementText");
12216}
12217
12218static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isPluginSnapshottedBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12219{
12220 auto& vm = JSC::getVM(lexicalGlobalObject);
12221 auto throwScope = DECLARE_THROW_SCOPE(vm);
12222 UNUSED_PARAM(throwScope);
12223 UNUSED_PARAM(callFrame);
12224 auto& impl = castedThis->wrapped();
12225 if (UNLIKELY(callFrame->argumentCount() < 1))
12226 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12227 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12228 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "isPluginSnapshotted", "Element"); });
12229 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12230 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isPluginSnapshotted(*element))));
12231}
12232
12233JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isPluginSnapshotted, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12234{
12235 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isPluginSnapshottedBody>(*lexicalGlobalObject, *callFrame, "isPluginSnapshotted");
12236}
12237
12238static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pluginIsBelowSizeThresholdBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12239{
12240 auto& vm = JSC::getVM(lexicalGlobalObject);
12241 auto throwScope = DECLARE_THROW_SCOPE(vm);
12242 UNUSED_PARAM(throwScope);
12243 UNUSED_PARAM(callFrame);
12244 auto& impl = castedThis->wrapped();
12245 if (UNLIKELY(callFrame->argumentCount() < 1))
12246 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12247 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12248 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "pluginIsBelowSizeThreshold", "Element"); });
12249 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12250 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.pluginIsBelowSizeThreshold(*element))));
12251}
12252
12253JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pluginIsBelowSizeThreshold, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12254{
12255 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pluginIsBelowSizeThresholdBody>(*lexicalGlobalObject, *callFrame, "pluginIsBelowSizeThreshold");
12256}
12257
12258static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_selectionBoundsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12259{
12260 auto& vm = JSC::getVM(lexicalGlobalObject);
12261 auto throwScope = DECLARE_THROW_SCOPE(vm);
12262 UNUSED_PARAM(throwScope);
12263 UNUSED_PARAM(callFrame);
12264 auto& impl = castedThis->wrapped();
12265 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<DOMRect>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.selectionBounds())));
12266}
12267
12268JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_selectionBounds, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12269{
12270 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_selectionBoundsBody>(*lexicalGlobalObject, *callFrame, "selectionBounds");
12271}
12272
12273static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setSelectionWithoutValidationBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12274{
12275 auto& vm = JSC::getVM(lexicalGlobalObject);
12276 auto throwScope = DECLARE_THROW_SCOPE(vm);
12277 UNUSED_PARAM(throwScope);
12278 UNUSED_PARAM(callFrame);
12279 auto& impl = castedThis->wrapped();
12280 if (UNLIKELY(callFrame->argumentCount() < 4))
12281 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12282 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12283 auto baseNode = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "baseNode", "Internals", "setSelectionWithoutValidation", "Node"); });
12284 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12285 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
12286 auto baseOffset = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument1.value());
12287 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12288 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
12289 auto extentNode = convert<IDLNullable<IDLInterface<Node>>>(*lexicalGlobalObject, argument2.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 2, "extentNode", "Internals", "setSelectionWithoutValidation", "Node"); });
12290 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12291 EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
12292 auto extentOffset = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument3.value());
12293 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12294 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setSelectionWithoutValidation(*baseNode, WTFMove(baseOffset), WTFMove(extentNode), WTFMove(extentOffset)); })));
12295}
12296
12297JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setSelectionWithoutValidation, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12298{
12299 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setSelectionWithoutValidationBody>(*lexicalGlobalObject, *callFrame, "setSelectionWithoutValidation");
12300}
12301
12302#if ENABLE(MEDIA_SOURCE)
12303static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_initializeMockMediaSourceBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12304{
12305 auto& vm = JSC::getVM(lexicalGlobalObject);
12306 auto throwScope = DECLARE_THROW_SCOPE(vm);
12307 UNUSED_PARAM(throwScope);
12308 UNUSED_PARAM(callFrame);
12309 auto& impl = castedThis->wrapped();
12310 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.initializeMockMediaSource(); })));
12311}
12312
12313JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_initializeMockMediaSource, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12314{
12315 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_initializeMockMediaSourceBody>(*lexicalGlobalObject, *callFrame, "initializeMockMediaSource");
12316}
12317
12318#endif
12319
12320#if ENABLE(MEDIA_SOURCE)
12321static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_bufferedSamplesForTrackIdBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
12322{
12323 auto& vm = JSC::getVM(lexicalGlobalObject);
12324 auto throwScope = DECLARE_THROW_SCOPE(vm);
12325 UNUSED_PARAM(throwScope);
12326 UNUSED_PARAM(callFrame);
12327 auto& impl = castedThis->wrapped();
12328 if (UNLIKELY(callFrame->argumentCount() < 2))
12329 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12330 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12331 auto buffer = convert<IDLInterface<SourceBuffer>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "buffer", "Internals", "bufferedSamplesForTrackId", "SourceBuffer"); });
12332 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12333 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
12334 auto trackId = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
12335 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12336 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLSequence<IDLDOMString>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.bufferedSamplesForTrackId(*buffer, WTFMove(trackId), WTFMove(promise)); })));
12337}
12338
12339JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_bufferedSamplesForTrackId, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12340{
12341 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunction_bufferedSamplesForTrackIdBody>(*lexicalGlobalObject, *callFrame, "bufferedSamplesForTrackId");
12342}
12343
12344#endif
12345
12346#if ENABLE(MEDIA_SOURCE)
12347static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_enqueuedSamplesForTrackIDBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
12348{
12349 auto& vm = JSC::getVM(lexicalGlobalObject);
12350 auto throwScope = DECLARE_THROW_SCOPE(vm);
12351 UNUSED_PARAM(throwScope);
12352 UNUSED_PARAM(callFrame);
12353 auto& impl = castedThis->wrapped();
12354 if (UNLIKELY(callFrame->argumentCount() < 2))
12355 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12356 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12357 auto buffer = convert<IDLInterface<SourceBuffer>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "buffer", "Internals", "enqueuedSamplesForTrackID", "SourceBuffer"); });
12358 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12359 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
12360 auto trackID = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
12361 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12362 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLSequence<IDLDOMString>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.enqueuedSamplesForTrackID(*buffer, WTFMove(trackID), WTFMove(promise)); })));
12363}
12364
12365JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_enqueuedSamplesForTrackID, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12366{
12367 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunction_enqueuedSamplesForTrackIDBody>(*lexicalGlobalObject, *callFrame, "enqueuedSamplesForTrackID");
12368}
12369
12370#endif
12371
12372#if ENABLE(MEDIA_SOURCE)
12373static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setShouldGenerateTimestampsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12374{
12375 auto& vm = JSC::getVM(lexicalGlobalObject);
12376 auto throwScope = DECLARE_THROW_SCOPE(vm);
12377 UNUSED_PARAM(throwScope);
12378 UNUSED_PARAM(callFrame);
12379 auto& impl = castedThis->wrapped();
12380 if (UNLIKELY(callFrame->argumentCount() < 2))
12381 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12382 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12383 auto buffer = convert<IDLInterface<SourceBuffer>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "buffer", "Internals", "setShouldGenerateTimestamps", "SourceBuffer"); });
12384 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12385 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
12386 auto flag = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
12387 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12388 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setShouldGenerateTimestamps(*buffer, WTFMove(flag)); })));
12389}
12390
12391JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setShouldGenerateTimestamps, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12392{
12393 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setShouldGenerateTimestampsBody>(*lexicalGlobalObject, *callFrame, "setShouldGenerateTimestamps");
12394}
12395
12396#endif
12397
12398#if ENABLE(MEDIA_SOURCE)
12399static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_minimumUpcomingPresentationTimeForTrackIDBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12400{
12401 auto& vm = JSC::getVM(lexicalGlobalObject);
12402 auto throwScope = DECLARE_THROW_SCOPE(vm);
12403 UNUSED_PARAM(throwScope);
12404 UNUSED_PARAM(callFrame);
12405 auto& impl = castedThis->wrapped();
12406 if (UNLIKELY(callFrame->argumentCount() < 2))
12407 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12408 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12409 auto buffer = convert<IDLInterface<SourceBuffer>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "buffer", "Internals", "minimumUpcomingPresentationTimeForTrackID", "SourceBuffer"); });
12410 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12411 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
12412 auto trackID = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
12413 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12414 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.minimumUpcomingPresentationTimeForTrackID(*buffer, WTFMove(trackID)))));
12415}
12416
12417JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_minimumUpcomingPresentationTimeForTrackID, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12418{
12419 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_minimumUpcomingPresentationTimeForTrackIDBody>(*lexicalGlobalObject, *callFrame, "minimumUpcomingPresentationTimeForTrackID");
12420}
12421
12422#endif
12423
12424#if ENABLE(MEDIA_SOURCE)
12425static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMaximumQueueDepthForTrackIDBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12426{
12427 auto& vm = JSC::getVM(lexicalGlobalObject);
12428 auto throwScope = DECLARE_THROW_SCOPE(vm);
12429 UNUSED_PARAM(throwScope);
12430 UNUSED_PARAM(callFrame);
12431 auto& impl = castedThis->wrapped();
12432 if (UNLIKELY(callFrame->argumentCount() < 3))
12433 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12434 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12435 auto buffer = convert<IDLInterface<SourceBuffer>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "buffer", "Internals", "setMaximumQueueDepthForTrackID", "SourceBuffer"); });
12436 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12437 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
12438 auto trackID = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
12439 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12440 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
12441 auto maxQueueDepth = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument2.value());
12442 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12443 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMaximumQueueDepthForTrackID(*buffer, WTFMove(trackID), WTFMove(maxQueueDepth)); })));
12444}
12445
12446JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMaximumQueueDepthForTrackID, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12447{
12448 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMaximumQueueDepthForTrackIDBody>(*lexicalGlobalObject, *callFrame, "setMaximumQueueDepthForTrackID");
12449}
12450
12451#endif
12452
12453#if ENABLE(VIDEO)
12454static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_beginMediaSessionInterruptionBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12455{
12456 auto& vm = JSC::getVM(lexicalGlobalObject);
12457 auto throwScope = DECLARE_THROW_SCOPE(vm);
12458 UNUSED_PARAM(throwScope);
12459 UNUSED_PARAM(callFrame);
12460 auto& impl = castedThis->wrapped();
12461 if (UNLIKELY(callFrame->argumentCount() < 1))
12462 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12463 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12464 auto interruptionType = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
12465 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12466 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.beginMediaSessionInterruption(WTFMove(interruptionType)); })));
12467}
12468
12469JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_beginMediaSessionInterruption, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12470{
12471 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_beginMediaSessionInterruptionBody>(*lexicalGlobalObject, *callFrame, "beginMediaSessionInterruption");
12472}
12473
12474#endif
12475
12476#if ENABLE(VIDEO)
12477static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_endMediaSessionInterruptionBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12478{
12479 auto& vm = JSC::getVM(lexicalGlobalObject);
12480 auto throwScope = DECLARE_THROW_SCOPE(vm);
12481 UNUSED_PARAM(throwScope);
12482 UNUSED_PARAM(callFrame);
12483 auto& impl = castedThis->wrapped();
12484 if (UNLIKELY(callFrame->argumentCount() < 1))
12485 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12486 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12487 auto flags = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
12488 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12489 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.endMediaSessionInterruption(WTFMove(flags)); })));
12490}
12491
12492JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_endMediaSessionInterruption, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12493{
12494 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_endMediaSessionInterruptionBody>(*lexicalGlobalObject, *callFrame, "endMediaSessionInterruption");
12495}
12496
12497#endif
12498
12499#if ENABLE(VIDEO)
12500static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_applicationWillBecomeInactiveBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12501{
12502 auto& vm = JSC::getVM(lexicalGlobalObject);
12503 auto throwScope = DECLARE_THROW_SCOPE(vm);
12504 UNUSED_PARAM(throwScope);
12505 UNUSED_PARAM(callFrame);
12506 auto& impl = castedThis->wrapped();
12507 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.applicationWillBecomeInactive(); })));
12508}
12509
12510JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_applicationWillBecomeInactive, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12511{
12512 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_applicationWillBecomeInactiveBody>(*lexicalGlobalObject, *callFrame, "applicationWillBecomeInactive");
12513}
12514
12515#endif
12516
12517#if ENABLE(VIDEO)
12518static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_applicationDidBecomeActiveBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12519{
12520 auto& vm = JSC::getVM(lexicalGlobalObject);
12521 auto throwScope = DECLARE_THROW_SCOPE(vm);
12522 UNUSED_PARAM(throwScope);
12523 UNUSED_PARAM(callFrame);
12524 auto& impl = castedThis->wrapped();
12525 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.applicationDidBecomeActive(); })));
12526}
12527
12528JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_applicationDidBecomeActive, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12529{
12530 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_applicationDidBecomeActiveBody>(*lexicalGlobalObject, *callFrame, "applicationDidBecomeActive");
12531}
12532
12533#endif
12534
12535#if ENABLE(VIDEO)
12536static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_applicationWillEnterForegroundBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12537{
12538 auto& vm = JSC::getVM(lexicalGlobalObject);
12539 auto throwScope = DECLARE_THROW_SCOPE(vm);
12540 UNUSED_PARAM(throwScope);
12541 UNUSED_PARAM(callFrame);
12542 auto& impl = castedThis->wrapped();
12543 EnsureStillAliveScope argument0 = callFrame->argument(0);
12544 auto suspendedUnderLock = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
12545 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12546 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.applicationWillEnterForeground(WTFMove(suspendedUnderLock)); })));
12547}
12548
12549JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_applicationWillEnterForeground, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12550{
12551 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_applicationWillEnterForegroundBody>(*lexicalGlobalObject, *callFrame, "applicationWillEnterForeground");
12552}
12553
12554#endif
12555
12556#if ENABLE(VIDEO)
12557static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_applicationDidEnterBackgroundBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12558{
12559 auto& vm = JSC::getVM(lexicalGlobalObject);
12560 auto throwScope = DECLARE_THROW_SCOPE(vm);
12561 UNUSED_PARAM(throwScope);
12562 UNUSED_PARAM(callFrame);
12563 auto& impl = castedThis->wrapped();
12564 EnsureStillAliveScope argument0 = callFrame->argument(0);
12565 auto suspendedUnderLock = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
12566 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12567 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.applicationDidEnterBackground(WTFMove(suspendedUnderLock)); })));
12568}
12569
12570JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_applicationDidEnterBackground, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12571{
12572 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_applicationDidEnterBackgroundBody>(*lexicalGlobalObject, *callFrame, "applicationDidEnterBackground");
12573}
12574
12575#endif
12576
12577#if ENABLE(VIDEO)
12578static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMediaSessionRestrictionsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12579{
12580 auto& vm = JSC::getVM(lexicalGlobalObject);
12581 auto throwScope = DECLARE_THROW_SCOPE(vm);
12582 UNUSED_PARAM(throwScope);
12583 UNUSED_PARAM(callFrame);
12584 auto& impl = castedThis->wrapped();
12585 if (UNLIKELY(callFrame->argumentCount() < 2))
12586 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12587 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12588 auto mediaType = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
12589 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12590 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
12591 auto restrictions = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
12592 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12593 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMediaSessionRestrictions(WTFMove(mediaType), WTFMove(restrictions)); })));
12594}
12595
12596JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMediaSessionRestrictions, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12597{
12598 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMediaSessionRestrictionsBody>(*lexicalGlobalObject, *callFrame, "setMediaSessionRestrictions");
12599}
12600
12601#endif
12602
12603#if ENABLE(VIDEO)
12604static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_mediaSessionRestrictionsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12605{
12606 auto& vm = JSC::getVM(lexicalGlobalObject);
12607 auto throwScope = DECLARE_THROW_SCOPE(vm);
12608 UNUSED_PARAM(throwScope);
12609 UNUSED_PARAM(callFrame);
12610 auto& impl = castedThis->wrapped();
12611 if (UNLIKELY(callFrame->argumentCount() < 1))
12612 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12613 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12614 auto mediaType = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
12615 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12616 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.mediaSessionRestrictions(WTFMove(mediaType)))));
12617}
12618
12619JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaSessionRestrictions, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12620{
12621 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_mediaSessionRestrictionsBody>(*lexicalGlobalObject, *callFrame, "mediaSessionRestrictions");
12622}
12623
12624#endif
12625
12626#if ENABLE(VIDEO)
12627static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMediaElementRestrictionsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12628{
12629 auto& vm = JSC::getVM(lexicalGlobalObject);
12630 auto throwScope = DECLARE_THROW_SCOPE(vm);
12631 UNUSED_PARAM(throwScope);
12632 UNUSED_PARAM(callFrame);
12633 auto& impl = castedThis->wrapped();
12634 if (UNLIKELY(callFrame->argumentCount() < 2))
12635 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12636 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12637 auto element = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "setMediaElementRestrictions", "HTMLMediaElement"); });
12638 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12639 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
12640 auto restrictions = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
12641 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12642 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMediaElementRestrictions(*element, WTFMove(restrictions)); })));
12643}
12644
12645JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMediaElementRestrictions, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12646{
12647 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMediaElementRestrictionsBody>(*lexicalGlobalObject, *callFrame, "setMediaElementRestrictions");
12648}
12649
12650#endif
12651
12652#if ENABLE(WEB_AUDIO)
12653static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setAudioContextRestrictionsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12654{
12655 auto& vm = JSC::getVM(lexicalGlobalObject);
12656 auto throwScope = DECLARE_THROW_SCOPE(vm);
12657 UNUSED_PARAM(throwScope);
12658 UNUSED_PARAM(callFrame);
12659 auto& impl = castedThis->wrapped();
12660 if (UNLIKELY(callFrame->argumentCount() < 2))
12661 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12662 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12663 auto context = convert<IDLInterface<AudioContext>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "context", "Internals", "setAudioContextRestrictions", "AudioContext"); });
12664 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12665 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
12666 auto restrictions = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
12667 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12668 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setAudioContextRestrictions(*context, WTFMove(restrictions)); })));
12669}
12670
12671JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAudioContextRestrictions, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12672{
12673 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setAudioContextRestrictionsBody>(*lexicalGlobalObject, *callFrame, "setAudioContextRestrictions");
12674}
12675
12676#endif
12677
12678#if ENABLE(VIDEO)
12679static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_postRemoteControlCommandBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12680{
12681 auto& vm = JSC::getVM(lexicalGlobalObject);
12682 auto throwScope = DECLARE_THROW_SCOPE(vm);
12683 UNUSED_PARAM(throwScope);
12684 UNUSED_PARAM(callFrame);
12685 auto& impl = castedThis->wrapped();
12686 if (UNLIKELY(callFrame->argumentCount() < 1))
12687 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12688 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12689 auto command = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
12690 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12691 EnsureStillAliveScope argument1 = callFrame->argument(1);
12692 auto argument = argument1.value().isUndefined() ? 0 : convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument1.value());
12693 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12694 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.postRemoteControlCommand(WTFMove(command), WTFMove(argument)); })));
12695}
12696
12697JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_postRemoteControlCommand, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12698{
12699 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_postRemoteControlCommandBody>(*lexicalGlobalObject, *callFrame, "postRemoteControlCommand");
12700}
12701
12702#endif
12703
12704#if ENABLE(VIDEO)
12705static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_activeAudioRouteDidChangeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12706{
12707 auto& vm = JSC::getVM(lexicalGlobalObject);
12708 auto throwScope = DECLARE_THROW_SCOPE(vm);
12709 UNUSED_PARAM(throwScope);
12710 UNUSED_PARAM(callFrame);
12711 auto& impl = castedThis->wrapped();
12712 if (UNLIKELY(callFrame->argumentCount() < 1))
12713 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12714 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12715 auto shouldPause = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
12716 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12717 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.activeAudioRouteDidChange(WTFMove(shouldPause)); })));
12718}
12719
12720JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_activeAudioRouteDidChange, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12721{
12722 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_activeAudioRouteDidChangeBody>(*lexicalGlobalObject, *callFrame, "activeAudioRouteDidChange");
12723}
12724
12725#endif
12726
12727#if ENABLE(WIRELESS_PLAYBACK_TARGET)
12728static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMockMediaPlaybackTargetPickerEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12729{
12730 auto& vm = JSC::getVM(lexicalGlobalObject);
12731 auto throwScope = DECLARE_THROW_SCOPE(vm);
12732 UNUSED_PARAM(throwScope);
12733 UNUSED_PARAM(callFrame);
12734 auto& impl = castedThis->wrapped();
12735 if (UNLIKELY(callFrame->argumentCount() < 1))
12736 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12737 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12738 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
12739 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12740 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMockMediaPlaybackTargetPickerEnabled(WTFMove(enabled)); })));
12741}
12742
12743JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMockMediaPlaybackTargetPickerEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12744{
12745 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMockMediaPlaybackTargetPickerEnabledBody>(*lexicalGlobalObject, *callFrame, "setMockMediaPlaybackTargetPickerEnabled");
12746}
12747
12748#endif
12749
12750#if ENABLE(WIRELESS_PLAYBACK_TARGET)
12751static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMockMediaPlaybackTargetPickerStateBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12752{
12753 auto& vm = JSC::getVM(lexicalGlobalObject);
12754 auto throwScope = DECLARE_THROW_SCOPE(vm);
12755 UNUSED_PARAM(throwScope);
12756 UNUSED_PARAM(callFrame);
12757 auto& impl = castedThis->wrapped();
12758 if (UNLIKELY(callFrame->argumentCount() < 2))
12759 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12760 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12761 auto deviceName = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
12762 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12763 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
12764 auto deviceState = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
12765 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12766 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMockMediaPlaybackTargetPickerState(WTFMove(deviceName), WTFMove(deviceState)); })));
12767}
12768
12769JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMockMediaPlaybackTargetPickerState, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12770{
12771 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMockMediaPlaybackTargetPickerStateBody>(*lexicalGlobalObject, *callFrame, "setMockMediaPlaybackTargetPickerState");
12772}
12773
12774#endif
12775
12776#if ENABLE(WIRELESS_PLAYBACK_TARGET)
12777static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_mockMediaPlaybackTargetPickerDismissPopupBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12778{
12779 auto& vm = JSC::getVM(lexicalGlobalObject);
12780 auto throwScope = DECLARE_THROW_SCOPE(vm);
12781 UNUSED_PARAM(throwScope);
12782 UNUSED_PARAM(callFrame);
12783 auto& impl = castedThis->wrapped();
12784 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.mockMediaPlaybackTargetPickerDismissPopup(); })));
12785}
12786
12787JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_mockMediaPlaybackTargetPickerDismissPopup, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12788{
12789 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_mockMediaPlaybackTargetPickerDismissPopupBody>(*lexicalGlobalObject, *callFrame, "mockMediaPlaybackTargetPickerDismissPopup");
12790}
12791
12792#endif
12793
12794#if ENABLE(MEDIA_STREAM)
12795static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setCustomPrivateRecorderCreatorBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12796{
12797 auto& vm = JSC::getVM(lexicalGlobalObject);
12798 auto throwScope = DECLARE_THROW_SCOPE(vm);
12799 UNUSED_PARAM(throwScope);
12800 UNUSED_PARAM(callFrame);
12801 auto& impl = castedThis->wrapped();
12802 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setCustomPrivateRecorderCreator(); })));
12803}
12804
12805JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setCustomPrivateRecorderCreator, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12806{
12807 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setCustomPrivateRecorderCreatorBody>(*lexicalGlobalObject, *callFrame, "setCustomPrivateRecorderCreator");
12808}
12809
12810#endif
12811
12812#if ENABLE(WEB_AUDIO)
12813static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_useMockAudioDestinationCocoaBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12814{
12815 auto& vm = JSC::getVM(lexicalGlobalObject);
12816 auto throwScope = DECLARE_THROW_SCOPE(vm);
12817 UNUSED_PARAM(throwScope);
12818 UNUSED_PARAM(callFrame);
12819 auto& impl = castedThis->wrapped();
12820 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.useMockAudioDestinationCocoa(); })));
12821}
12822
12823JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_useMockAudioDestinationCocoa, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12824{
12825 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_useMockAudioDestinationCocoaBody>(*lexicalGlobalObject, *callFrame, "useMockAudioDestinationCocoa");
12826}
12827
12828#endif
12829
12830#if ENABLE(WEB_RTC)
12831static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_emulateRTCPeerConnectionPlatformEventBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12832{
12833 auto& vm = JSC::getVM(lexicalGlobalObject);
12834 auto throwScope = DECLARE_THROW_SCOPE(vm);
12835 UNUSED_PARAM(throwScope);
12836 UNUSED_PARAM(callFrame);
12837 auto& impl = castedThis->wrapped();
12838 if (UNLIKELY(callFrame->argumentCount() < 2))
12839 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12840 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12841 auto connection = convert<IDLInterface<RTCPeerConnection>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "connection", "Internals", "emulateRTCPeerConnectionPlatformEvent", "RTCPeerConnection"); });
12842 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12843 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
12844 auto action = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
12845 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12846 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.emulateRTCPeerConnectionPlatformEvent(*connection, WTFMove(action)); })));
12847}
12848
12849JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_emulateRTCPeerConnectionPlatformEvent, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12850{
12851 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_emulateRTCPeerConnectionPlatformEventBody>(*lexicalGlobalObject, *callFrame, "emulateRTCPeerConnectionPlatformEvent");
12852}
12853
12854#endif
12855
12856#if ENABLE(WEB_RTC)
12857static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_useMockRTCPeerConnectionFactoryBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12858{
12859 auto& vm = JSC::getVM(lexicalGlobalObject);
12860 auto throwScope = DECLARE_THROW_SCOPE(vm);
12861 UNUSED_PARAM(throwScope);
12862 UNUSED_PARAM(callFrame);
12863 auto& impl = castedThis->wrapped();
12864 if (UNLIKELY(callFrame->argumentCount() < 1))
12865 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12866 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12867 auto testCase = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
12868 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12869 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.useMockRTCPeerConnectionFactory(WTFMove(testCase)); })));
12870}
12871
12872JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_useMockRTCPeerConnectionFactory, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12873{
12874 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_useMockRTCPeerConnectionFactoryBody>(*lexicalGlobalObject, *callFrame, "useMockRTCPeerConnectionFactory");
12875}
12876
12877#endif
12878
12879#if ENABLE(WEB_RTC)
12880static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setICECandidateFilteringBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12881{
12882 auto& vm = JSC::getVM(lexicalGlobalObject);
12883 auto throwScope = DECLARE_THROW_SCOPE(vm);
12884 UNUSED_PARAM(throwScope);
12885 UNUSED_PARAM(callFrame);
12886 auto& impl = castedThis->wrapped();
12887 if (UNLIKELY(callFrame->argumentCount() < 1))
12888 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12889 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12890 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
12891 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12892 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setICECandidateFiltering(WTFMove(enabled)); })));
12893}
12894
12895JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setICECandidateFiltering, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12896{
12897 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setICECandidateFilteringBody>(*lexicalGlobalObject, *callFrame, "setICECandidateFiltering");
12898}
12899
12900#endif
12901
12902#if ENABLE(WEB_RTC)
12903static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setEnumeratingAllNetworkInterfacesEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12904{
12905 auto& vm = JSC::getVM(lexicalGlobalObject);
12906 auto throwScope = DECLARE_THROW_SCOPE(vm);
12907 UNUSED_PARAM(throwScope);
12908 UNUSED_PARAM(callFrame);
12909 auto& impl = castedThis->wrapped();
12910 if (UNLIKELY(callFrame->argumentCount() < 1))
12911 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12912 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12913 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
12914 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12915 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setEnumeratingAllNetworkInterfacesEnabled(WTFMove(enabled)); })));
12916}
12917
12918JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setEnumeratingAllNetworkInterfacesEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12919{
12920 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setEnumeratingAllNetworkInterfacesEnabledBody>(*lexicalGlobalObject, *callFrame, "setEnumeratingAllNetworkInterfacesEnabled");
12921}
12922
12923#endif
12924
12925#if ENABLE(WEB_RTC)
12926static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_stopPeerConnectionBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12927{
12928 auto& vm = JSC::getVM(lexicalGlobalObject);
12929 auto throwScope = DECLARE_THROW_SCOPE(vm);
12930 UNUSED_PARAM(throwScope);
12931 UNUSED_PARAM(callFrame);
12932 auto& impl = castedThis->wrapped();
12933 if (UNLIKELY(callFrame->argumentCount() < 1))
12934 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12935 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12936 auto connection = convert<IDLInterface<RTCPeerConnection>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "connection", "Internals", "stopPeerConnection", "RTCPeerConnection"); });
12937 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12938 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.stopPeerConnection(*connection); })));
12939}
12940
12941JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_stopPeerConnection, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12942{
12943 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_stopPeerConnectionBody>(*lexicalGlobalObject, *callFrame, "stopPeerConnection");
12944}
12945
12946#endif
12947
12948#if ENABLE(WEB_RTC)
12949static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_clearPeerConnectionFactoryBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12950{
12951 auto& vm = JSC::getVM(lexicalGlobalObject);
12952 auto throwScope = DECLARE_THROW_SCOPE(vm);
12953 UNUSED_PARAM(throwScope);
12954 UNUSED_PARAM(callFrame);
12955 auto& impl = castedThis->wrapped();
12956 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.clearPeerConnectionFactory(); })));
12957}
12958
12959JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_clearPeerConnectionFactory, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12960{
12961 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_clearPeerConnectionFactoryBody>(*lexicalGlobalObject, *callFrame, "clearPeerConnectionFactory");
12962}
12963
12964#endif
12965
12966#if ENABLE(WEB_RTC)
12967static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setEnableWebRTCEncryptionBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12968{
12969 auto& vm = JSC::getVM(lexicalGlobalObject);
12970 auto throwScope = DECLARE_THROW_SCOPE(vm);
12971 UNUSED_PARAM(throwScope);
12972 UNUSED_PARAM(callFrame);
12973 auto& impl = castedThis->wrapped();
12974 if (UNLIKELY(callFrame->argumentCount() < 1))
12975 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12976 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
12977 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
12978 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
12979 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setEnableWebRTCEncryption(WTFMove(enabled)); })));
12980}
12981
12982JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setEnableWebRTCEncryption, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
12983{
12984 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setEnableWebRTCEncryptionBody>(*lexicalGlobalObject, *callFrame, "setEnableWebRTCEncryption");
12985}
12986
12987#endif
12988
12989#if ENABLE(WEB_RTC)
12990static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setUseDTLS10Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
12991{
12992 auto& vm = JSC::getVM(lexicalGlobalObject);
12993 auto throwScope = DECLARE_THROW_SCOPE(vm);
12994 UNUSED_PARAM(throwScope);
12995 UNUSED_PARAM(callFrame);
12996 auto& impl = castedThis->wrapped();
12997 if (UNLIKELY(callFrame->argumentCount() < 1))
12998 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
12999 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13000 auto use = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
13001 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13002 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setUseDTLS10(WTFMove(use)); })));
13003}
13004
13005JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUseDTLS10, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13006{
13007 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setUseDTLS10Body>(*lexicalGlobalObject, *callFrame, "setUseDTLS10");
13008}
13009
13010#endif
13011
13012#if ENABLE(VIDEO)
13013static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_simulateSystemSleepBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13014{
13015 auto& vm = JSC::getVM(lexicalGlobalObject);
13016 auto throwScope = DECLARE_THROW_SCOPE(vm);
13017 UNUSED_PARAM(throwScope);
13018 UNUSED_PARAM(callFrame);
13019 auto& impl = castedThis->wrapped();
13020 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.simulateSystemSleep(); })));
13021}
13022
13023JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_simulateSystemSleep, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13024{
13025 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_simulateSystemSleepBody>(*lexicalGlobalObject, *callFrame, "simulateSystemSleep");
13026}
13027
13028#endif
13029
13030#if ENABLE(VIDEO)
13031static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_simulateSystemWakeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13032{
13033 auto& vm = JSC::getVM(lexicalGlobalObject);
13034 auto throwScope = DECLARE_THROW_SCOPE(vm);
13035 UNUSED_PARAM(throwScope);
13036 UNUSED_PARAM(callFrame);
13037 auto& impl = castedThis->wrapped();
13038 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.simulateSystemWake(); })));
13039}
13040
13041JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_simulateSystemWake, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13042{
13043 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_simulateSystemWakeBody>(*lexicalGlobalObject, *callFrame, "simulateSystemWake");
13044}
13045
13046#endif
13047
13048#if ENABLE(VIDEO)
13049static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_elementIsBlockingDisplaySleepBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13050{
13051 auto& vm = JSC::getVM(lexicalGlobalObject);
13052 auto throwScope = DECLARE_THROW_SCOPE(vm);
13053 UNUSED_PARAM(throwScope);
13054 UNUSED_PARAM(callFrame);
13055 auto& impl = castedThis->wrapped();
13056 if (UNLIKELY(callFrame->argumentCount() < 1))
13057 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13058 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13059 auto element = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "elementIsBlockingDisplaySleep", "HTMLMediaElement"); });
13060 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13061 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.elementIsBlockingDisplaySleep(*element))));
13062}
13063
13064JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_elementIsBlockingDisplaySleep, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13065{
13066 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_elementIsBlockingDisplaySleepBody>(*lexicalGlobalObject, *callFrame, "elementIsBlockingDisplaySleep");
13067}
13068
13069#endif
13070
13071static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_installMockPageOverlayBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13072{
13073 auto& vm = JSC::getVM(lexicalGlobalObject);
13074 auto throwScope = DECLARE_THROW_SCOPE(vm);
13075 UNUSED_PARAM(throwScope);
13076 UNUSED_PARAM(callFrame);
13077 auto& impl = castedThis->wrapped();
13078 if (UNLIKELY(callFrame->argumentCount() < 1))
13079 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13080 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13081 auto type = convert<IDLEnumeration<Internals::PageOverlayType>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 0, "type", "Internals", "installMockPageOverlay", expectedEnumerationValues<Internals::PageOverlayType>()); });
13082 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13083 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<MockPageOverlay>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.installMockPageOverlay(WTFMove(type)))));
13084}
13085
13086JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_installMockPageOverlay, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13087{
13088 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_installMockPageOverlayBody>(*lexicalGlobalObject, *callFrame, "installMockPageOverlay");
13089}
13090
13091static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pageOverlayLayerTreeAsTextBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13092{
13093 auto& vm = JSC::getVM(lexicalGlobalObject);
13094 auto throwScope = DECLARE_THROW_SCOPE(vm);
13095 UNUSED_PARAM(throwScope);
13096 UNUSED_PARAM(callFrame);
13097 auto& impl = castedThis->wrapped();
13098 EnsureStillAliveScope argument0 = callFrame->argument(0);
13099 auto flags = convert<IDLUnsignedShort>(*lexicalGlobalObject, argument0.value());
13100 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13101 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.pageOverlayLayerTreeAsText(WTFMove(flags)))));
13102}
13103
13104JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageOverlayLayerTreeAsText, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13105{
13106 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pageOverlayLayerTreeAsTextBody>(*lexicalGlobalObject, *callFrame, "pageOverlayLayerTreeAsText");
13107}
13108
13109static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setPageMutedBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13110{
13111 auto& vm = JSC::getVM(lexicalGlobalObject);
13112 auto throwScope = DECLARE_THROW_SCOPE(vm);
13113 UNUSED_PARAM(throwScope);
13114 UNUSED_PARAM(callFrame);
13115 auto& impl = castedThis->wrapped();
13116 if (UNLIKELY(callFrame->argumentCount() < 1))
13117 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13118 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13119 auto mutedState = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
13120 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13121 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setPageMuted(WTFMove(mutedState)); })));
13122}
13123
13124JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageMuted, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13125{
13126 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setPageMutedBody>(*lexicalGlobalObject, *callFrame, "setPageMuted");
13127}
13128
13129static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pageMediaStateBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13130{
13131 auto& vm = JSC::getVM(lexicalGlobalObject);
13132 auto throwScope = DECLARE_THROW_SCOPE(vm);
13133 UNUSED_PARAM(throwScope);
13134 UNUSED_PARAM(callFrame);
13135 auto& impl = castedThis->wrapped();
13136 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.pageMediaState())));
13137}
13138
13139JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageMediaState, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13140{
13141 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pageMediaStateBody>(*lexicalGlobalObject, *callFrame, "pageMediaState");
13142}
13143
13144static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setPageDefersLoadingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13145{
13146 auto& vm = JSC::getVM(lexicalGlobalObject);
13147 auto throwScope = DECLARE_THROW_SCOPE(vm);
13148 UNUSED_PARAM(throwScope);
13149 UNUSED_PARAM(callFrame);
13150 auto& impl = castedThis->wrapped();
13151 if (UNLIKELY(callFrame->argumentCount() < 1))
13152 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13153 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13154 auto defersLoading = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
13155 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13156 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setPageDefersLoading(WTFMove(defersLoading)); })));
13157}
13158
13159JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageDefersLoading, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13160{
13161 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setPageDefersLoadingBody>(*lexicalGlobalObject, *callFrame, "setPageDefersLoading");
13162}
13163
13164static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pageDefersLoadingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13165{
13166 auto& vm = JSC::getVM(lexicalGlobalObject);
13167 auto throwScope = DECLARE_THROW_SCOPE(vm);
13168 UNUSED_PARAM(throwScope);
13169 UNUSED_PARAM(callFrame);
13170 auto& impl = castedThis->wrapped();
13171 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.pageDefersLoading())));
13172}
13173
13174JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageDefersLoading, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13175{
13176 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pageDefersLoadingBody>(*lexicalGlobalObject, *callFrame, "pageDefersLoading");
13177}
13178
13179static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_createFileBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13180{
13181 auto& vm = JSC::getVM(lexicalGlobalObject);
13182 auto throwScope = DECLARE_THROW_SCOPE(vm);
13183 UNUSED_PARAM(throwScope);
13184 UNUSED_PARAM(callFrame);
13185 auto& impl = castedThis->wrapped();
13186 if (UNLIKELY(callFrame->argumentCount() < 1))
13187 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13188 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13189 auto url = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
13190 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13191 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLInterface<File>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.createFile(WTFMove(url)))));
13192}
13193
13194JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_createFile, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13195{
13196 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_createFileBody>(*lexicalGlobalObject, *callFrame, "createFile");
13197}
13198
13199static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_queueMicroTaskBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13200{
13201 auto& vm = JSC::getVM(lexicalGlobalObject);
13202 auto throwScope = DECLARE_THROW_SCOPE(vm);
13203 UNUSED_PARAM(throwScope);
13204 UNUSED_PARAM(callFrame);
13205 auto& impl = castedThis->wrapped();
13206 if (UNLIKELY(callFrame->argumentCount() < 1))
13207 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13208 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13209 auto testNumber = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
13210 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13211 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.queueMicroTask(WTFMove(testNumber)); })));
13212}
13213
13214JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_queueMicroTask, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13215{
13216 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_queueMicroTaskBody>(*lexicalGlobalObject, *callFrame, "queueMicroTask");
13217}
13218
13219static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_testPreloaderSettingViewportBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13220{
13221 auto& vm = JSC::getVM(lexicalGlobalObject);
13222 auto throwScope = DECLARE_THROW_SCOPE(vm);
13223 UNUSED_PARAM(throwScope);
13224 UNUSED_PARAM(callFrame);
13225 auto& impl = castedThis->wrapped();
13226 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.testPreloaderSettingViewport())));
13227}
13228
13229JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_testPreloaderSettingViewport, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13230{
13231 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_testPreloaderSettingViewportBody>(*lexicalGlobalObject, *callFrame, "testPreloaderSettingViewport");
13232}
13233
13234static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_scrollSnapOffsetsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13235{
13236 auto& vm = JSC::getVM(lexicalGlobalObject);
13237 auto throwScope = DECLARE_THROW_SCOPE(vm);
13238 UNUSED_PARAM(throwScope);
13239 UNUSED_PARAM(callFrame);
13240 auto& impl = castedThis->wrapped();
13241 if (UNLIKELY(callFrame->argumentCount() < 1))
13242 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13243 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13244 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "scrollSnapOffsets", "Element"); });
13245 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13246 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.scrollSnapOffsets(*element))));
13247}
13248
13249JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_scrollSnapOffsets, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13250{
13251 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_scrollSnapOffsetsBody>(*lexicalGlobalObject, *callFrame, "scrollSnapOffsets");
13252}
13253
13254static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isScrollSnapInProgressBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13255{
13256 auto& vm = JSC::getVM(lexicalGlobalObject);
13257 auto throwScope = DECLARE_THROW_SCOPE(vm);
13258 UNUSED_PARAM(throwScope);
13259 UNUSED_PARAM(callFrame);
13260 auto& impl = castedThis->wrapped();
13261 if (UNLIKELY(callFrame->argumentCount() < 1))
13262 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13263 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13264 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "isScrollSnapInProgress", "Element"); });
13265 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13266 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isScrollSnapInProgress(*element))));
13267}
13268
13269JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isScrollSnapInProgress, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13270{
13271 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isScrollSnapInProgressBody>(*lexicalGlobalObject, *callFrame, "isScrollSnapInProgress");
13272}
13273
13274static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setPlatformMomentumScrollingPredictionEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13275{
13276 auto& vm = JSC::getVM(lexicalGlobalObject);
13277 auto throwScope = DECLARE_THROW_SCOPE(vm);
13278 UNUSED_PARAM(throwScope);
13279 UNUSED_PARAM(callFrame);
13280 auto& impl = castedThis->wrapped();
13281 if (UNLIKELY(callFrame->argumentCount() < 1))
13282 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13283 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13284 auto enabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
13285 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13286 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setPlatformMomentumScrollingPredictionEnabled(WTFMove(enabled)); })));
13287}
13288
13289JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPlatformMomentumScrollingPredictionEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13290{
13291 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setPlatformMomentumScrollingPredictionEnabledBody>(*lexicalGlobalObject, *callFrame, "setPlatformMomentumScrollingPredictionEnabled");
13292}
13293
13294static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pathStringWithShrinkWrappedRectsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13295{
13296 auto& vm = JSC::getVM(lexicalGlobalObject);
13297 auto throwScope = DECLARE_THROW_SCOPE(vm);
13298 UNUSED_PARAM(throwScope);
13299 UNUSED_PARAM(callFrame);
13300 auto& impl = castedThis->wrapped();
13301 if (UNLIKELY(callFrame->argumentCount() < 2))
13302 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13303 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13304 auto rectComponents = convert<IDLSequence<IDLDouble>>(*lexicalGlobalObject, argument0.value());
13305 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13306 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
13307 auto radius = convert<IDLDouble>(*lexicalGlobalObject, argument1.value());
13308 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13309 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.pathStringWithShrinkWrappedRects(WTFMove(rectComponents), WTFMove(radius)))));
13310}
13311
13312JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pathStringWithShrinkWrappedRects, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13313{
13314 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pathStringWithShrinkWrappedRectsBody>(*lexicalGlobalObject, *callFrame, "pathStringWithShrinkWrappedRects");
13315}
13316
13317#if ENABLE(VIDEO)
13318static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_getCurrentMediaControlsStatusForElementBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13319{
13320 auto& vm = JSC::getVM(lexicalGlobalObject);
13321 auto throwScope = DECLARE_THROW_SCOPE(vm);
13322 UNUSED_PARAM(throwScope);
13323 UNUSED_PARAM(callFrame);
13324 auto& impl = castedThis->wrapped();
13325 if (UNLIKELY(callFrame->argumentCount() < 1))
13326 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13327 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13328 auto element = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "getCurrentMediaControlsStatusForElement", "HTMLMediaElement"); });
13329 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13330 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.getCurrentMediaControlsStatusForElement(*element))));
13331}
13332
13333JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_getCurrentMediaControlsStatusForElement, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13334{
13335 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_getCurrentMediaControlsStatusForElementBody>(*lexicalGlobalObject, *callFrame, "getCurrentMediaControlsStatusForElement");
13336}
13337
13338#endif
13339
13340#if ENABLE(VIDEO)
13341static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMediaControlsMaximumRightContainerButtonCountOverrideBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13342{
13343 auto& vm = JSC::getVM(lexicalGlobalObject);
13344 auto throwScope = DECLARE_THROW_SCOPE(vm);
13345 UNUSED_PARAM(throwScope);
13346 UNUSED_PARAM(callFrame);
13347 auto& impl = castedThis->wrapped();
13348 if (UNLIKELY(callFrame->argumentCount() < 2))
13349 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13350 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13351 auto element = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "setMediaControlsMaximumRightContainerButtonCountOverride", "HTMLMediaElement"); });
13352 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13353 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
13354 auto count = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument1.value());
13355 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13356 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMediaControlsMaximumRightContainerButtonCountOverride(*element, WTFMove(count)); })));
13357}
13358
13359JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMediaControlsMaximumRightContainerButtonCountOverride, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13360{
13361 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMediaControlsMaximumRightContainerButtonCountOverrideBody>(*lexicalGlobalObject, *callFrame, "setMediaControlsMaximumRightContainerButtonCountOverride");
13362}
13363
13364#endif
13365
13366#if ENABLE(VIDEO)
13367static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMediaControlsHidePlaybackRatesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13368{
13369 auto& vm = JSC::getVM(lexicalGlobalObject);
13370 auto throwScope = DECLARE_THROW_SCOPE(vm);
13371 UNUSED_PARAM(throwScope);
13372 UNUSED_PARAM(callFrame);
13373 auto& impl = castedThis->wrapped();
13374 if (UNLIKELY(callFrame->argumentCount() < 2))
13375 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13376 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13377 auto element = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "setMediaControlsHidePlaybackRates", "HTMLMediaElement"); });
13378 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13379 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
13380 auto hidePlaybackRates = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
13381 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13382 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMediaControlsHidePlaybackRates(*element, WTFMove(hidePlaybackRates)); })));
13383}
13384
13385JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMediaControlsHidePlaybackRates, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13386{
13387 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMediaControlsHidePlaybackRatesBody>(*lexicalGlobalObject, *callFrame, "setMediaControlsHidePlaybackRates");
13388}
13389
13390#endif
13391
13392static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_userVisibleStringBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13393{
13394 auto& vm = JSC::getVM(lexicalGlobalObject);
13395 auto throwScope = DECLARE_THROW_SCOPE(vm);
13396 UNUSED_PARAM(throwScope);
13397 UNUSED_PARAM(callFrame);
13398 auto& impl = castedThis->wrapped();
13399 if (UNLIKELY(callFrame->argumentCount() < 1))
13400 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13401 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13402 auto url = convert<IDLInterface<DOMURL>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "url", "Internals", "userVisibleString", "DOMURL"); });
13403 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13404 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.userVisibleString(*url))));
13405}
13406
13407JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_userVisibleString, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13408{
13409 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_userVisibleStringBody>(*lexicalGlobalObject, *callFrame, "userVisibleString");
13410}
13411
13412static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setPageMediaVolumeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13413{
13414 auto& vm = JSC::getVM(lexicalGlobalObject);
13415 auto throwScope = DECLARE_THROW_SCOPE(vm);
13416 UNUSED_PARAM(throwScope);
13417 UNUSED_PARAM(callFrame);
13418 auto& impl = castedThis->wrapped();
13419 if (UNLIKELY(callFrame->argumentCount() < 1))
13420 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13421 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13422 auto volume = convert<IDLFloat>(*lexicalGlobalObject, argument0.value());
13423 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13424 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setPageMediaVolume(WTFMove(volume)); })));
13425}
13426
13427JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageMediaVolume, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13428{
13429 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setPageMediaVolumeBody>(*lexicalGlobalObject, *callFrame, "setPageMediaVolume");
13430}
13431
13432static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setShowAllPluginsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13433{
13434 auto& vm = JSC::getVM(lexicalGlobalObject);
13435 auto throwScope = DECLARE_THROW_SCOPE(vm);
13436 UNUSED_PARAM(throwScope);
13437 UNUSED_PARAM(callFrame);
13438 auto& impl = castedThis->wrapped();
13439 if (UNLIKELY(callFrame->argumentCount() < 1))
13440 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13441 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13442 auto showAll = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
13443 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13444 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setShowAllPlugins(WTFMove(showAll)); })));
13445}
13446
13447JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setShowAllPlugins, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13448{
13449 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setShowAllPluginsBody>(*lexicalGlobalObject, *callFrame, "setShowAllPlugins");
13450}
13451
13452static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_cloneArrayBufferBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13453{
13454 auto& vm = JSC::getVM(lexicalGlobalObject);
13455 auto throwScope = DECLARE_THROW_SCOPE(vm);
13456 UNUSED_PARAM(throwScope);
13457 UNUSED_PARAM(callFrame);
13458 auto& impl = castedThis->wrapped();
13459 if (UNLIKELY(callFrame->argumentCount() < 3))
13460 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13461 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13462 auto buffer = convert<IDLAny>(*lexicalGlobalObject, argument0.value());
13463 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13464 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
13465 auto srcByteOffset = convert<IDLAny>(*lexicalGlobalObject, argument1.value());
13466 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13467 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
13468 auto byteLength = convert<IDLAny>(*lexicalGlobalObject, argument2.value());
13469 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13470 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLAny>(*lexicalGlobalObject, throwScope, impl.cloneArrayBuffer(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTFMove(buffer), WTFMove(srcByteOffset), WTFMove(byteLength)))));
13471}
13472
13473JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_cloneArrayBuffer, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13474{
13475 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_cloneArrayBufferBody>(*lexicalGlobalObject, *callFrame, "cloneArrayBuffer");
13476}
13477
13478static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isReadableStreamDisturbedBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13479{
13480 auto& vm = JSC::getVM(lexicalGlobalObject);
13481 auto throwScope = DECLARE_THROW_SCOPE(vm);
13482 UNUSED_PARAM(throwScope);
13483 UNUSED_PARAM(callFrame);
13484 auto& impl = castedThis->wrapped();
13485 if (UNLIKELY(callFrame->argumentCount() < 1))
13486 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13487 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13488 auto stream = convert<IDLAny>(*lexicalGlobalObject, argument0.value());
13489 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13490 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isReadableStreamDisturbed(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTFMove(stream)))));
13491}
13492
13493JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isReadableStreamDisturbed, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13494{
13495 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isReadableStreamDisturbedBody>(*lexicalGlobalObject, *callFrame, "isReadableStreamDisturbed");
13496}
13497
13498static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_resourceLoadStatisticsForURLBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13499{
13500 auto& vm = JSC::getVM(lexicalGlobalObject);
13501 auto throwScope = DECLARE_THROW_SCOPE(vm);
13502 UNUSED_PARAM(throwScope);
13503 UNUSED_PARAM(callFrame);
13504 auto& impl = castedThis->wrapped();
13505 if (UNLIKELY(callFrame->argumentCount() < 1))
13506 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13507 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13508 auto url = convert<IDLInterface<DOMURL>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "url", "Internals", "resourceLoadStatisticsForURL", "DOMURL"); });
13509 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13510 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.resourceLoadStatisticsForURL(*url))));
13511}
13512
13513JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_resourceLoadStatisticsForURL, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13514{
13515 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_resourceLoadStatisticsForURLBody>(*lexicalGlobalObject, *callFrame, "resourceLoadStatisticsForURL");
13516}
13517
13518static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setResourceLoadStatisticsEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13519{
13520 auto& vm = JSC::getVM(lexicalGlobalObject);
13521 auto throwScope = DECLARE_THROW_SCOPE(vm);
13522 UNUSED_PARAM(throwScope);
13523 UNUSED_PARAM(callFrame);
13524 auto& impl = castedThis->wrapped();
13525 if (UNLIKELY(callFrame->argumentCount() < 1))
13526 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13527 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13528 auto enable = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
13529 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13530 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setResourceLoadStatisticsEnabled(WTFMove(enable)); })));
13531}
13532
13533JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setResourceLoadStatisticsEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13534{
13535 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setResourceLoadStatisticsEnabledBody>(*lexicalGlobalObject, *callFrame, "setResourceLoadStatisticsEnabled");
13536}
13537
13538static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setCanShowModalDialogOverrideBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13539{
13540 auto& vm = JSC::getVM(lexicalGlobalObject);
13541 auto throwScope = DECLARE_THROW_SCOPE(vm);
13542 UNUSED_PARAM(throwScope);
13543 UNUSED_PARAM(callFrame);
13544 auto& impl = castedThis->wrapped();
13545 if (UNLIKELY(callFrame->argumentCount() < 1))
13546 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13547 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13548 auto allow = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
13549 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13550 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setCanShowModalDialogOverride(WTFMove(allow)); })));
13551}
13552
13553JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setCanShowModalDialogOverride, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13554{
13555 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setCanShowModalDialogOverrideBody>(*lexicalGlobalObject, *callFrame, "setCanShowModalDialogOverride");
13556}
13557
13558static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_composedTreeAsTextBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13559{
13560 auto& vm = JSC::getVM(lexicalGlobalObject);
13561 auto throwScope = DECLARE_THROW_SCOPE(vm);
13562 UNUSED_PARAM(throwScope);
13563 UNUSED_PARAM(callFrame);
13564 auto& impl = castedThis->wrapped();
13565 if (UNLIKELY(callFrame->argumentCount() < 1))
13566 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13567 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13568 auto parent = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "parent", "Internals", "composedTreeAsText", "Node"); });
13569 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13570 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.composedTreeAsText(*parent))));
13571}
13572
13573JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_composedTreeAsText, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13574{
13575 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_composedTreeAsTextBody>(*lexicalGlobalObject, *callFrame, "composedTreeAsText");
13576}
13577
13578static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isProcessingUserGestureBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13579{
13580 auto& vm = JSC::getVM(lexicalGlobalObject);
13581 auto throwScope = DECLARE_THROW_SCOPE(vm);
13582 UNUSED_PARAM(throwScope);
13583 UNUSED_PARAM(callFrame);
13584 auto& impl = castedThis->wrapped();
13585 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isProcessingUserGesture())));
13586}
13587
13588JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isProcessingUserGesture, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13589{
13590 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isProcessingUserGestureBody>(*lexicalGlobalObject, *callFrame, "isProcessingUserGesture");
13591}
13592
13593static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_lastHandledUserGestureTimestampBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13594{
13595 auto& vm = JSC::getVM(lexicalGlobalObject);
13596 auto throwScope = DECLARE_THROW_SCOPE(vm);
13597 UNUSED_PARAM(throwScope);
13598 UNUSED_PARAM(callFrame);
13599 auto& impl = castedThis->wrapped();
13600 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.lastHandledUserGestureTimestamp())));
13601}
13602
13603JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_lastHandledUserGestureTimestamp, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13604{
13605 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_lastHandledUserGestureTimestampBody>(*lexicalGlobalObject, *callFrame, "lastHandledUserGestureTimestamp");
13606}
13607
13608static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_withUserGestureBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13609{
13610 auto& vm = JSC::getVM(lexicalGlobalObject);
13611 auto throwScope = DECLARE_THROW_SCOPE(vm);
13612 UNUSED_PARAM(throwScope);
13613 UNUSED_PARAM(callFrame);
13614 auto& impl = castedThis->wrapped();
13615 if (UNLIKELY(callFrame->argumentCount() < 1))
13616 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13617 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13618 auto callback = convert<IDLCallbackFunction<JSVoidCallback>>(*lexicalGlobalObject, argument0.value(), *castedThis->globalObject(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(lexicalGlobalObject, scope, 0, "callback", "Internals", "withUserGesture"); });
13619 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13620 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.withUserGesture(callback.releaseNonNull()); })));
13621}
13622
13623JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_withUserGesture, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13624{
13625 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_withUserGestureBody>(*lexicalGlobalObject, *callFrame, "withUserGesture");
13626}
13627
13628static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_withoutUserGestureBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13629{
13630 auto& vm = JSC::getVM(lexicalGlobalObject);
13631 auto throwScope = DECLARE_THROW_SCOPE(vm);
13632 UNUSED_PARAM(throwScope);
13633 UNUSED_PARAM(callFrame);
13634 auto& impl = castedThis->wrapped();
13635 if (UNLIKELY(callFrame->argumentCount() < 1))
13636 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13637 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13638 auto callback = convert<IDLCallbackFunction<JSVoidCallback>>(*lexicalGlobalObject, argument0.value(), *castedThis->globalObject(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(lexicalGlobalObject, scope, 0, "callback", "Internals", "withoutUserGesture"); });
13639 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13640 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.withoutUserGesture(callback.releaseNonNull()); })));
13641}
13642
13643JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_withoutUserGesture, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13644{
13645 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_withoutUserGestureBody>(*lexicalGlobalObject, *callFrame, "withoutUserGesture");
13646}
13647
13648static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_userIsInteractingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13649{
13650 auto& vm = JSC::getVM(lexicalGlobalObject);
13651 auto throwScope = DECLARE_THROW_SCOPE(vm);
13652 UNUSED_PARAM(throwScope);
13653 UNUSED_PARAM(callFrame);
13654 auto& impl = castedThis->wrapped();
13655 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.userIsInteracting())));
13656}
13657
13658JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_userIsInteracting, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13659{
13660 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_userIsInteractingBody>(*lexicalGlobalObject, *callFrame, "userIsInteracting");
13661}
13662
13663static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_observeGCBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13664{
13665 auto& vm = JSC::getVM(lexicalGlobalObject);
13666 auto throwScope = DECLARE_THROW_SCOPE(vm);
13667 UNUSED_PARAM(throwScope);
13668 UNUSED_PARAM(callFrame);
13669 auto& impl = castedThis->wrapped();
13670 if (UNLIKELY(callFrame->argumentCount() < 1))
13671 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13672 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13673 auto observed = convert<IDLAny>(*lexicalGlobalObject, argument0.value());
13674 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13675 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLInterface<GCObservation>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.observeGC(WTFMove(observed)))));
13676}
13677
13678JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_observeGC, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13679{
13680 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_observeGCBody>(*lexicalGlobalObject, *callFrame, "observeGC");
13681}
13682
13683static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setUserInterfaceLayoutDirectionBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13684{
13685 auto& vm = JSC::getVM(lexicalGlobalObject);
13686 auto throwScope = DECLARE_THROW_SCOPE(vm);
13687 UNUSED_PARAM(throwScope);
13688 UNUSED_PARAM(callFrame);
13689 auto& impl = castedThis->wrapped();
13690 if (UNLIKELY(callFrame->argumentCount() < 1))
13691 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13692 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13693 auto userInterfaceLayoutDirection = convert<IDLEnumeration<Internals::UserInterfaceLayoutDirection>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 0, "userInterfaceLayoutDirection", "Internals", "setUserInterfaceLayoutDirection", expectedEnumerationValues<Internals::UserInterfaceLayoutDirection>()); });
13694 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13695 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setUserInterfaceLayoutDirection(WTFMove(userInterfaceLayoutDirection)); })));
13696}
13697
13698JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUserInterfaceLayoutDirection, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13699{
13700 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setUserInterfaceLayoutDirectionBody>(*lexicalGlobalObject, *callFrame, "setUserInterfaceLayoutDirection");
13701}
13702
13703static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setBaseWritingDirectionBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13704{
13705 auto& vm = JSC::getVM(lexicalGlobalObject);
13706 auto throwScope = DECLARE_THROW_SCOPE(vm);
13707 UNUSED_PARAM(throwScope);
13708 UNUSED_PARAM(callFrame);
13709 auto& impl = castedThis->wrapped();
13710 if (UNLIKELY(callFrame->argumentCount() < 1))
13711 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13712 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13713 auto direction = convert<IDLEnumeration<Internals::BaseWritingDirection>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 0, "direction", "Internals", "setBaseWritingDirection", expectedEnumerationValues<Internals::BaseWritingDirection>()); });
13714 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13715 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setBaseWritingDirection(WTFMove(direction)); })));
13716}
13717
13718JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setBaseWritingDirection, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13719{
13720 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setBaseWritingDirectionBody>(*lexicalGlobalObject, *callFrame, "setBaseWritingDirection");
13721}
13722
13723static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_userPrefersContrastBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13724{
13725 auto& vm = JSC::getVM(lexicalGlobalObject);
13726 auto throwScope = DECLARE_THROW_SCOPE(vm);
13727 UNUSED_PARAM(throwScope);
13728 UNUSED_PARAM(callFrame);
13729 auto& impl = castedThis->wrapped();
13730 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.userPrefersContrast())));
13731}
13732
13733JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_userPrefersContrast, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13734{
13735 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_userPrefersContrastBody>(*lexicalGlobalObject, *callFrame, "userPrefersContrast");
13736}
13737
13738static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_userPrefersReducedMotionBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13739{
13740 auto& vm = JSC::getVM(lexicalGlobalObject);
13741 auto throwScope = DECLARE_THROW_SCOPE(vm);
13742 UNUSED_PARAM(throwScope);
13743 UNUSED_PARAM(callFrame);
13744 auto& impl = castedThis->wrapped();
13745 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.userPrefersReducedMotion())));
13746}
13747
13748JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_userPrefersReducedMotion, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13749{
13750 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_userPrefersReducedMotionBody>(*lexicalGlobalObject, *callFrame, "userPrefersReducedMotion");
13751}
13752
13753static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_reportBacktraceBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13754{
13755 auto& vm = JSC::getVM(lexicalGlobalObject);
13756 auto throwScope = DECLARE_THROW_SCOPE(vm);
13757 UNUSED_PARAM(throwScope);
13758 UNUSED_PARAM(callFrame);
13759 auto& impl = castedThis->wrapped();
13760 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.reportBacktrace(); })));
13761}
13762
13763JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_reportBacktrace, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13764{
13765 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_reportBacktraceBody>(*lexicalGlobalObject, *callFrame, "reportBacktrace");
13766}
13767
13768#if ENABLE(POINTER_LOCK)
13769static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pageHasPendingPointerLockBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13770{
13771 auto& vm = JSC::getVM(lexicalGlobalObject);
13772 auto throwScope = DECLARE_THROW_SCOPE(vm);
13773 UNUSED_PARAM(throwScope);
13774 UNUSED_PARAM(callFrame);
13775 auto& impl = castedThis->wrapped();
13776 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.pageHasPendingPointerLock())));
13777}
13778
13779JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageHasPendingPointerLock, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13780{
13781 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pageHasPendingPointerLockBody>(*lexicalGlobalObject, *callFrame, "pageHasPendingPointerLock");
13782}
13783
13784#endif
13785
13786#if ENABLE(POINTER_LOCK)
13787static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pageHasPointerLockBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13788{
13789 auto& vm = JSC::getVM(lexicalGlobalObject);
13790 auto throwScope = DECLARE_THROW_SCOPE(vm);
13791 UNUSED_PARAM(throwScope);
13792 UNUSED_PARAM(callFrame);
13793 auto& impl = castedThis->wrapped();
13794 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.pageHasPointerLock())));
13795}
13796
13797JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageHasPointerLock, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13798{
13799 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pageHasPointerLockBody>(*lexicalGlobalObject, *callFrame, "pageHasPointerLock");
13800}
13801
13802#endif
13803
13804static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_accessKeyModifiersBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13805{
13806 auto& vm = JSC::getVM(lexicalGlobalObject);
13807 auto throwScope = DECLARE_THROW_SCOPE(vm);
13808 UNUSED_PARAM(throwScope);
13809 UNUSED_PARAM(callFrame);
13810 auto& impl = castedThis->wrapped();
13811 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.accessKeyModifiers())));
13812}
13813
13814JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_accessKeyModifiers, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13815{
13816 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_accessKeyModifiersBody>(*lexicalGlobalObject, *callFrame, "accessKeyModifiers");
13817}
13818
13819static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setQuickLookPasswordBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13820{
13821 auto& vm = JSC::getVM(lexicalGlobalObject);
13822 auto throwScope = DECLARE_THROW_SCOPE(vm);
13823 UNUSED_PARAM(throwScope);
13824 UNUSED_PARAM(callFrame);
13825 auto& impl = castedThis->wrapped();
13826 if (UNLIKELY(callFrame->argumentCount() < 1))
13827 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13828 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13829 auto password = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
13830 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13831 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setQuickLookPassword(WTFMove(password)); })));
13832}
13833
13834JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setQuickLookPassword, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13835{
13836 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setQuickLookPasswordBody>(*lexicalGlobalObject, *callFrame, "setQuickLookPassword");
13837}
13838
13839static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setAsRunningUserScriptsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13840{
13841 auto& vm = JSC::getVM(lexicalGlobalObject);
13842 auto throwScope = DECLARE_THROW_SCOPE(vm);
13843 UNUSED_PARAM(throwScope);
13844 UNUSED_PARAM(callFrame);
13845 auto& impl = castedThis->wrapped();
13846 auto* context = jsCast<JSDOMGlobalObject*>(lexicalGlobalObject)->scriptExecutionContext();
13847 if (UNLIKELY(!context))
13848 return JSValue::encode(jsUndefined());
13849 ASSERT(context->isDocument());
13850 auto& document = downcast<Document>(*context);
13851 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setAsRunningUserScripts(document); })));
13852}
13853
13854JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAsRunningUserScripts, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13855{
13856 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setAsRunningUserScriptsBody>(*lexicalGlobalObject, *callFrame, "setAsRunningUserScripts");
13857}
13858
13859#if ENABLE(APPLE_PAY)
13860static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setApplePayIsActiveBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13861{
13862 auto& vm = JSC::getVM(lexicalGlobalObject);
13863 auto throwScope = DECLARE_THROW_SCOPE(vm);
13864 UNUSED_PARAM(throwScope);
13865 UNUSED_PARAM(callFrame);
13866 auto& impl = castedThis->wrapped();
13867 auto* context = jsCast<JSDOMGlobalObject*>(lexicalGlobalObject)->scriptExecutionContext();
13868 if (UNLIKELY(!context))
13869 return JSValue::encode(jsUndefined());
13870 ASSERT(context->isDocument());
13871 auto& document = downcast<Document>(*context);
13872 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setApplePayIsActive(document); })));
13873}
13874
13875JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setApplePayIsActive, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13876{
13877 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setApplePayIsActiveBody>(*lexicalGlobalObject, *callFrame, "setApplePayIsActive");
13878}
13879
13880#endif
13881
13882static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_disableTileSizeUpdateDelayBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13883{
13884 auto& vm = JSC::getVM(lexicalGlobalObject);
13885 auto throwScope = DECLARE_THROW_SCOPE(vm);
13886 UNUSED_PARAM(throwScope);
13887 UNUSED_PARAM(callFrame);
13888 auto& impl = castedThis->wrapped();
13889 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.disableTileSizeUpdateDelay(); })));
13890}
13891
13892JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_disableTileSizeUpdateDelay, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13893{
13894 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_disableTileSizeUpdateDelayBody>(*lexicalGlobalObject, *callFrame, "disableTileSizeUpdateDelay");
13895}
13896
13897static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setSpeculativeTilingDelayDisabledForTestingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13898{
13899 auto& vm = JSC::getVM(lexicalGlobalObject);
13900 auto throwScope = DECLARE_THROW_SCOPE(vm);
13901 UNUSED_PARAM(throwScope);
13902 UNUSED_PARAM(callFrame);
13903 auto& impl = castedThis->wrapped();
13904 if (UNLIKELY(callFrame->argumentCount() < 1))
13905 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13906 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13907 auto disabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
13908 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13909 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setSpeculativeTilingDelayDisabledForTesting(WTFMove(disabled)); })));
13910}
13911
13912JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setSpeculativeTilingDelayDisabledForTesting, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13913{
13914 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setSpeculativeTilingDelayDisabledForTestingBody>(*lexicalGlobalObject, *callFrame, "setSpeculativeTilingDelayDisabledForTesting");
13915}
13916
13917#if ENABLE(WEBGL)
13918static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_simulateEventForWebGLContextBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13919{
13920 auto& vm = JSC::getVM(lexicalGlobalObject);
13921 auto throwScope = DECLARE_THROW_SCOPE(vm);
13922 UNUSED_PARAM(throwScope);
13923 UNUSED_PARAM(callFrame);
13924 auto& impl = castedThis->wrapped();
13925 if (UNLIKELY(callFrame->argumentCount() < 2))
13926 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13927 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13928 auto event = convert<IDLEnumeration<Internals::SimulatedWebGLContextEvent>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 0, "event", "Internals", "simulateEventForWebGLContext", expectedEnumerationValues<Internals::SimulatedWebGLContextEvent>()); });
13929 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13930 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
13931 auto context = convert<IDLInterface<WebGLRenderingContext>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "context", "Internals", "simulateEventForWebGLContext", "WebGLRenderingContext"); });
13932 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13933 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.simulateEventForWebGLContext(WTFMove(event), *context); })));
13934}
13935
13936JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_simulateEventForWebGLContext, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13937{
13938 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_simulateEventForWebGLContextBody>(*lexicalGlobalObject, *callFrame, "simulateEventForWebGLContext");
13939}
13940
13941#endif
13942
13943#if ENABLE(WEBGL)
13944static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_hasLowAndHighPowerGPUsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13945{
13946 auto& vm = JSC::getVM(lexicalGlobalObject);
13947 auto throwScope = DECLARE_THROW_SCOPE(vm);
13948 UNUSED_PARAM(throwScope);
13949 UNUSED_PARAM(callFrame);
13950 auto& impl = castedThis->wrapped();
13951 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.hasLowAndHighPowerGPUs())));
13952}
13953
13954JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasLowAndHighPowerGPUs, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13955{
13956 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_hasLowAndHighPowerGPUsBody>(*lexicalGlobalObject, *callFrame, "hasLowAndHighPowerGPUs");
13957}
13958
13959#endif
13960
13961static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setPageVisibilityBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13962{
13963 auto& vm = JSC::getVM(lexicalGlobalObject);
13964 auto throwScope = DECLARE_THROW_SCOPE(vm);
13965 UNUSED_PARAM(throwScope);
13966 UNUSED_PARAM(callFrame);
13967 auto& impl = castedThis->wrapped();
13968 if (UNLIKELY(callFrame->argumentCount() < 1))
13969 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13970 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13971 auto isVisible = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
13972 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13973 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setPageVisibility(WTFMove(isVisible)); })));
13974}
13975
13976JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageVisibility, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13977{
13978 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setPageVisibilityBody>(*lexicalGlobalObject, *callFrame, "setPageVisibility");
13979}
13980
13981static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setPageIsFocusedAndActiveBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
13982{
13983 auto& vm = JSC::getVM(lexicalGlobalObject);
13984 auto throwScope = DECLARE_THROW_SCOPE(vm);
13985 UNUSED_PARAM(throwScope);
13986 UNUSED_PARAM(callFrame);
13987 auto& impl = castedThis->wrapped();
13988 if (UNLIKELY(callFrame->argumentCount() < 1))
13989 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
13990 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
13991 auto isFocused = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
13992 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
13993 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setPageIsFocusedAndActive(WTFMove(isFocused)); })));
13994}
13995
13996JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageIsFocusedAndActive, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
13997{
13998 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setPageIsFocusedAndActiveBody>(*lexicalGlobalObject, *callFrame, "setPageIsFocusedAndActive");
13999}
14000
14001static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setPageIsInWindowBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14002{
14003 auto& vm = JSC::getVM(lexicalGlobalObject);
14004 auto throwScope = DECLARE_THROW_SCOPE(vm);
14005 UNUSED_PARAM(throwScope);
14006 UNUSED_PARAM(callFrame);
14007 auto& impl = castedThis->wrapped();
14008 if (UNLIKELY(callFrame->argumentCount() < 1))
14009 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14010 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14011 auto isInWindow = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
14012 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14013 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setPageIsInWindow(WTFMove(isInWindow)); })));
14014}
14015
14016JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setPageIsInWindow, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14017{
14018 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setPageIsInWindowBody>(*lexicalGlobalObject, *callFrame, "setPageIsInWindow");
14019}
14020
14021static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isPageActiveBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14022{
14023 auto& vm = JSC::getVM(lexicalGlobalObject);
14024 auto throwScope = DECLARE_THROW_SCOPE(vm);
14025 UNUSED_PARAM(throwScope);
14026 UNUSED_PARAM(callFrame);
14027 auto& impl = castedThis->wrapped();
14028 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isPageActive())));
14029}
14030
14031JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isPageActive, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14032{
14033 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isPageActiveBody>(*lexicalGlobalObject, *callFrame, "isPageActive");
14034}
14035
14036#if ENABLE(WEB_RTC)
14037static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setH264HardwareEncoderAllowedBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14038{
14039 auto& vm = JSC::getVM(lexicalGlobalObject);
14040 auto throwScope = DECLARE_THROW_SCOPE(vm);
14041 UNUSED_PARAM(throwScope);
14042 UNUSED_PARAM(callFrame);
14043 auto& impl = castedThis->wrapped();
14044 if (UNLIKELY(callFrame->argumentCount() < 1))
14045 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14046 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14047 auto allowed = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
14048 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14049 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setH264HardwareEncoderAllowed(WTFMove(allowed)); })));
14050}
14051
14052JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setH264HardwareEncoderAllowed, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14053{
14054 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setH264HardwareEncoderAllowedBody>(*lexicalGlobalObject, *callFrame, "setH264HardwareEncoderAllowed");
14055}
14056
14057#endif
14058
14059#if ENABLE(WEB_RTC)
14060static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_applyRotationForOutgoingVideoSourcesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14061{
14062 auto& vm = JSC::getVM(lexicalGlobalObject);
14063 auto throwScope = DECLARE_THROW_SCOPE(vm);
14064 UNUSED_PARAM(throwScope);
14065 UNUSED_PARAM(callFrame);
14066 auto& impl = castedThis->wrapped();
14067 if (UNLIKELY(callFrame->argumentCount() < 1))
14068 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14069 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14070 auto connection = convert<IDLInterface<RTCPeerConnection>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "connection", "Internals", "applyRotationForOutgoingVideoSources", "RTCPeerConnection"); });
14071 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14072 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.applyRotationForOutgoingVideoSources(*connection); })));
14073}
14074
14075JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_applyRotationForOutgoingVideoSources, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14076{
14077 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_applyRotationForOutgoingVideoSourcesBody>(*lexicalGlobalObject, *callFrame, "applyRotationForOutgoingVideoSources");
14078}
14079
14080#endif
14081
14082#if ENABLE(WEB_RTC)
14083static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setWebRTCH265SupportBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14084{
14085 auto& vm = JSC::getVM(lexicalGlobalObject);
14086 auto throwScope = DECLARE_THROW_SCOPE(vm);
14087 UNUSED_PARAM(throwScope);
14088 UNUSED_PARAM(callFrame);
14089 auto& impl = castedThis->wrapped();
14090 if (UNLIKELY(callFrame->argumentCount() < 1))
14091 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14092 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14093 auto allowed = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
14094 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14095 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setWebRTCH265Support(WTFMove(allowed)); })));
14096}
14097
14098JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setWebRTCH265Support, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14099{
14100 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setWebRTCH265SupportBody>(*lexicalGlobalObject, *callFrame, "setWebRTCH265Support");
14101}
14102
14103#endif
14104
14105#if ENABLE(WEB_RTC)
14106static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setWebRTCVP9SupportBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14107{
14108 auto& vm = JSC::getVM(lexicalGlobalObject);
14109 auto throwScope = DECLARE_THROW_SCOPE(vm);
14110 UNUSED_PARAM(throwScope);
14111 UNUSED_PARAM(callFrame);
14112 auto& impl = castedThis->wrapped();
14113 if (UNLIKELY(callFrame->argumentCount() < 2))
14114 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14115 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14116 auto supportVP9Profile0 = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
14117 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14118 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
14119 auto supportVP9Profile2 = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
14120 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14121 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setWebRTCVP9Support(WTFMove(supportVP9Profile0), WTFMove(supportVP9Profile2)); })));
14122}
14123
14124JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setWebRTCVP9Support, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14125{
14126 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setWebRTCVP9SupportBody>(*lexicalGlobalObject, *callFrame, "setWebRTCVP9Support");
14127}
14128
14129#endif
14130
14131#if ENABLE(WEB_RTC)
14132static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setWebRTCVP9VTBSupportBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14133{
14134 auto& vm = JSC::getVM(lexicalGlobalObject);
14135 auto throwScope = DECLARE_THROW_SCOPE(vm);
14136 UNUSED_PARAM(throwScope);
14137 UNUSED_PARAM(callFrame);
14138 auto& impl = castedThis->wrapped();
14139 if (UNLIKELY(callFrame->argumentCount() < 1))
14140 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14141 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14142 auto allowed = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
14143 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14144 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setWebRTCVP9VTBSupport(WTFMove(allowed)); })));
14145}
14146
14147JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setWebRTCVP9VTBSupport, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14148{
14149 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setWebRTCVP9VTBSupportBody>(*lexicalGlobalObject, *callFrame, "setWebRTCVP9VTBSupport");
14150}
14151
14152#endif
14153
14154#if ENABLE(WEB_RTC)
14155static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setSFrameCounterBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14156{
14157 auto& vm = JSC::getVM(lexicalGlobalObject);
14158 auto throwScope = DECLARE_THROW_SCOPE(vm);
14159 UNUSED_PARAM(throwScope);
14160 UNUSED_PARAM(callFrame);
14161 auto& impl = castedThis->wrapped();
14162 if (UNLIKELY(callFrame->argumentCount() < 2))
14163 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14164 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14165 auto transform = convert<IDLInterface<RTCRtpSFrameTransform>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "transform", "Internals", "setSFrameCounter", "RTCRtpSFrameTransform"); });
14166 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14167 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
14168 auto counter = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
14169 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14170 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setSFrameCounter(*transform, WTFMove(counter)); })));
14171}
14172
14173JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setSFrameCounter, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14174{
14175 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setSFrameCounterBody>(*lexicalGlobalObject, *callFrame, "setSFrameCounter");
14176}
14177
14178#endif
14179
14180#if ENABLE(WEB_RTC)
14181static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_sframeCounterBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14182{
14183 auto& vm = JSC::getVM(lexicalGlobalObject);
14184 auto throwScope = DECLARE_THROW_SCOPE(vm);
14185 UNUSED_PARAM(throwScope);
14186 UNUSED_PARAM(callFrame);
14187 auto& impl = castedThis->wrapped();
14188 if (UNLIKELY(callFrame->argumentCount() < 1))
14189 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14190 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14191 auto transform = convert<IDLInterface<RTCRtpSFrameTransform>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "transform", "Internals", "sframeCounter", "RTCRtpSFrameTransform"); });
14192 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14193 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLongLong>(*lexicalGlobalObject, throwScope, impl.sframeCounter(*transform))));
14194}
14195
14196JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_sframeCounter, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14197{
14198 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_sframeCounterBody>(*lexicalGlobalObject, *callFrame, "sframeCounter");
14199}
14200
14201#endif
14202
14203#if ENABLE(WEB_RTC)
14204static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_sframeKeyIdBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14205{
14206 auto& vm = JSC::getVM(lexicalGlobalObject);
14207 auto throwScope = DECLARE_THROW_SCOPE(vm);
14208 UNUSED_PARAM(throwScope);
14209 UNUSED_PARAM(callFrame);
14210 auto& impl = castedThis->wrapped();
14211 if (UNLIKELY(callFrame->argumentCount() < 1))
14212 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14213 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14214 auto transform = convert<IDLInterface<RTCRtpSFrameTransform>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "transform", "Internals", "sframeKeyId", "RTCRtpSFrameTransform"); });
14215 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14216 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLongLong>(*lexicalGlobalObject, throwScope, impl.sframeKeyId(*transform))));
14217}
14218
14219JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_sframeKeyId, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14220{
14221 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_sframeKeyIdBody>(*lexicalGlobalObject, *callFrame, "sframeKeyId");
14222}
14223
14224#endif
14225
14226#if ENABLE(MEDIA_STREAM)
14227static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMockAudioTrackChannelNumberBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14228{
14229 auto& vm = JSC::getVM(lexicalGlobalObject);
14230 auto throwScope = DECLARE_THROW_SCOPE(vm);
14231 UNUSED_PARAM(throwScope);
14232 UNUSED_PARAM(callFrame);
14233 auto& impl = castedThis->wrapped();
14234 if (UNLIKELY(callFrame->argumentCount() < 2))
14235 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14236 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14237 auto track = convert<IDLInterface<MediaStreamTrack>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "track", "Internals", "setMockAudioTrackChannelNumber", "MediaStreamTrack"); });
14238 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14239 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
14240 auto count = convert<IDLUnsignedShort>(*lexicalGlobalObject, argument1.value());
14241 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14242 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMockAudioTrackChannelNumber(*track, WTFMove(count)); })));
14243}
14244
14245JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMockAudioTrackChannelNumber, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14246{
14247 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMockAudioTrackChannelNumberBody>(*lexicalGlobalObject, *callFrame, "setMockAudioTrackChannelNumber");
14248}
14249
14250#endif
14251
14252#if ENABLE(MEDIA_STREAM)
14253static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setShouldInterruptAudioOnPageVisibilityChangeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14254{
14255 auto& vm = JSC::getVM(lexicalGlobalObject);
14256 auto throwScope = DECLARE_THROW_SCOPE(vm);
14257 UNUSED_PARAM(throwScope);
14258 UNUSED_PARAM(callFrame);
14259 auto& impl = castedThis->wrapped();
14260 if (UNLIKELY(callFrame->argumentCount() < 1))
14261 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14262 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14263 auto shouldInterrupt = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
14264 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14265 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setShouldInterruptAudioOnPageVisibilityChange(WTFMove(shouldInterrupt)); })));
14266}
14267
14268JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setShouldInterruptAudioOnPageVisibilityChange, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14269{
14270 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setShouldInterruptAudioOnPageVisibilityChangeBody>(*lexicalGlobalObject, *callFrame, "setShouldInterruptAudioOnPageVisibilityChange");
14271}
14272
14273#endif
14274
14275#if ENABLE(MEDIA_STREAM)
14276static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setCameraMediaStreamTrackOrientationBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14277{
14278 auto& vm = JSC::getVM(lexicalGlobalObject);
14279 auto throwScope = DECLARE_THROW_SCOPE(vm);
14280 UNUSED_PARAM(throwScope);
14281 UNUSED_PARAM(callFrame);
14282 auto& impl = castedThis->wrapped();
14283 if (UNLIKELY(callFrame->argumentCount() < 2))
14284 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14285 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14286 auto track = convert<IDLInterface<MediaStreamTrack>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "track", "Internals", "setCameraMediaStreamTrackOrientation", "MediaStreamTrack"); });
14287 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14288 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
14289 auto orientation = convert<IDLShort>(*lexicalGlobalObject, argument1.value());
14290 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14291 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setCameraMediaStreamTrackOrientation(*track, WTFMove(orientation)); })));
14292}
14293
14294JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setCameraMediaStreamTrackOrientation, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14295{
14296 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setCameraMediaStreamTrackOrientationBody>(*lexicalGlobalObject, *callFrame, "setCameraMediaStreamTrackOrientation");
14297}
14298
14299#endif
14300
14301#if ENABLE(MEDIA_STREAM)
14302static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_observeMediaStreamTrackBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14303{
14304 auto& vm = JSC::getVM(lexicalGlobalObject);
14305 auto throwScope = DECLARE_THROW_SCOPE(vm);
14306 UNUSED_PARAM(throwScope);
14307 UNUSED_PARAM(callFrame);
14308 auto& impl = castedThis->wrapped();
14309 if (UNLIKELY(callFrame->argumentCount() < 1))
14310 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14311 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14312 auto track = convert<IDLInterface<MediaStreamTrack>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "track", "Internals", "observeMediaStreamTrack", "MediaStreamTrack"); });
14313 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14314 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.observeMediaStreamTrack(*track); })));
14315}
14316
14317JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_observeMediaStreamTrack, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14318{
14319 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_observeMediaStreamTrackBody>(*lexicalGlobalObject, *callFrame, "observeMediaStreamTrack");
14320}
14321
14322#endif
14323
14324#if ENABLE(MEDIA_STREAM)
14325static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_grabNextMediaStreamTrackFrameBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
14326{
14327 auto& vm = JSC::getVM(lexicalGlobalObject);
14328 auto throwScope = DECLARE_THROW_SCOPE(vm);
14329 UNUSED_PARAM(throwScope);
14330 UNUSED_PARAM(callFrame);
14331 auto& impl = castedThis->wrapped();
14332 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLInterface<ImageData>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.grabNextMediaStreamTrackFrame(WTFMove(promise)); })));
14333}
14334
14335JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_grabNextMediaStreamTrackFrame, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14336{
14337 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunction_grabNextMediaStreamTrackFrameBody>(*lexicalGlobalObject, *callFrame, "grabNextMediaStreamTrackFrame");
14338}
14339
14340#endif
14341
14342#if ENABLE(MEDIA_STREAM)
14343static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_delayMediaStreamTrackSamplesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14344{
14345 auto& vm = JSC::getVM(lexicalGlobalObject);
14346 auto throwScope = DECLARE_THROW_SCOPE(vm);
14347 UNUSED_PARAM(throwScope);
14348 UNUSED_PARAM(callFrame);
14349 auto& impl = castedThis->wrapped();
14350 if (UNLIKELY(callFrame->argumentCount() < 2))
14351 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14352 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14353 auto track = convert<IDLInterface<MediaStreamTrack>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "track", "Internals", "delayMediaStreamTrackSamples", "MediaStreamTrack"); });
14354 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14355 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
14356 auto delay = convert<IDLFloat>(*lexicalGlobalObject, argument1.value());
14357 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14358 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.delayMediaStreamTrackSamples(*track, WTFMove(delay)); })));
14359}
14360
14361JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_delayMediaStreamTrackSamples, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14362{
14363 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_delayMediaStreamTrackSamplesBody>(*lexicalGlobalObject, *callFrame, "delayMediaStreamTrackSamples");
14364}
14365
14366#endif
14367
14368#if ENABLE(MEDIA_STREAM)
14369static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMediaStreamTrackMutedBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14370{
14371 auto& vm = JSC::getVM(lexicalGlobalObject);
14372 auto throwScope = DECLARE_THROW_SCOPE(vm);
14373 UNUSED_PARAM(throwScope);
14374 UNUSED_PARAM(callFrame);
14375 auto& impl = castedThis->wrapped();
14376 if (UNLIKELY(callFrame->argumentCount() < 2))
14377 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14378 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14379 auto track = convert<IDLInterface<MediaStreamTrack>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "track", "Internals", "setMediaStreamTrackMuted", "MediaStreamTrack"); });
14380 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14381 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
14382 auto muted = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
14383 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14384 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMediaStreamTrackMuted(*track, WTFMove(muted)); })));
14385}
14386
14387JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMediaStreamTrackMuted, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14388{
14389 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMediaStreamTrackMutedBody>(*lexicalGlobalObject, *callFrame, "setMediaStreamTrackMuted");
14390}
14391
14392#endif
14393
14394#if ENABLE(MEDIA_STREAM)
14395static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_removeMediaStreamTrackBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14396{
14397 auto& vm = JSC::getVM(lexicalGlobalObject);
14398 auto throwScope = DECLARE_THROW_SCOPE(vm);
14399 UNUSED_PARAM(throwScope);
14400 UNUSED_PARAM(callFrame);
14401 auto& impl = castedThis->wrapped();
14402 if (UNLIKELY(callFrame->argumentCount() < 2))
14403 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14404 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14405 auto stream = convert<IDLInterface<MediaStream>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "stream", "Internals", "removeMediaStreamTrack", "MediaStream"); });
14406 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14407 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
14408 auto track = convert<IDLInterface<MediaStreamTrack>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "track", "Internals", "removeMediaStreamTrack", "MediaStreamTrack"); });
14409 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14410 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.removeMediaStreamTrack(*stream, *track); })));
14411}
14412
14413JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_removeMediaStreamTrack, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14414{
14415 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_removeMediaStreamTrackBody>(*lexicalGlobalObject, *callFrame, "removeMediaStreamTrack");
14416}
14417
14418#endif
14419
14420#if ENABLE(MEDIA_STREAM)
14421static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_simulateMediaStreamTrackCaptureSourceFailureBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14422{
14423 auto& vm = JSC::getVM(lexicalGlobalObject);
14424 auto throwScope = DECLARE_THROW_SCOPE(vm);
14425 UNUSED_PARAM(throwScope);
14426 UNUSED_PARAM(callFrame);
14427 auto& impl = castedThis->wrapped();
14428 if (UNLIKELY(callFrame->argumentCount() < 1))
14429 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14430 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14431 auto track = convert<IDLInterface<MediaStreamTrack>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "track", "Internals", "simulateMediaStreamTrackCaptureSourceFailure", "MediaStreamTrack"); });
14432 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14433 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.simulateMediaStreamTrackCaptureSourceFailure(*track); })));
14434}
14435
14436JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_simulateMediaStreamTrackCaptureSourceFailure, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14437{
14438 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_simulateMediaStreamTrackCaptureSourceFailureBody>(*lexicalGlobalObject, *callFrame, "simulateMediaStreamTrackCaptureSourceFailure");
14439}
14440
14441#endif
14442
14443#if ENABLE(MEDIA_STREAM)
14444static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMediaStreamTrackIdentifierBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14445{
14446 auto& vm = JSC::getVM(lexicalGlobalObject);
14447 auto throwScope = DECLARE_THROW_SCOPE(vm);
14448 UNUSED_PARAM(throwScope);
14449 UNUSED_PARAM(callFrame);
14450 auto& impl = castedThis->wrapped();
14451 if (UNLIKELY(callFrame->argumentCount() < 2))
14452 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14453 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14454 auto track = convert<IDLInterface<MediaStreamTrack>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "track", "Internals", "setMediaStreamTrackIdentifier", "MediaStreamTrack"); });
14455 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14456 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
14457 auto identifier = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
14458 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14459 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMediaStreamTrackIdentifier(*track, WTFMove(identifier)); })));
14460}
14461
14462JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMediaStreamTrackIdentifier, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14463{
14464 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMediaStreamTrackIdentifierBody>(*lexicalGlobalObject, *callFrame, "setMediaStreamTrackIdentifier");
14465}
14466
14467#endif
14468
14469#if ENABLE(MEDIA_STREAM)
14470static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMediaStreamSourceInterruptedBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14471{
14472 auto& vm = JSC::getVM(lexicalGlobalObject);
14473 auto throwScope = DECLARE_THROW_SCOPE(vm);
14474 UNUSED_PARAM(throwScope);
14475 UNUSED_PARAM(callFrame);
14476 auto& impl = castedThis->wrapped();
14477 if (UNLIKELY(callFrame->argumentCount() < 2))
14478 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14479 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14480 auto track = convert<IDLInterface<MediaStreamTrack>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "track", "Internals", "setMediaStreamSourceInterrupted", "MediaStreamTrack"); });
14481 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14482 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
14483 auto interrupted = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
14484 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14485 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMediaStreamSourceInterrupted(*track, WTFMove(interrupted)); })));
14486}
14487
14488JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMediaStreamSourceInterrupted, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14489{
14490 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMediaStreamSourceInterruptedBody>(*lexicalGlobalObject, *callFrame, "setMediaStreamSourceInterrupted");
14491}
14492
14493#endif
14494
14495#if ENABLE(MEDIA_STREAM)
14496static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isMediaStreamSourceInterruptedBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14497{
14498 auto& vm = JSC::getVM(lexicalGlobalObject);
14499 auto throwScope = DECLARE_THROW_SCOPE(vm);
14500 UNUSED_PARAM(throwScope);
14501 UNUSED_PARAM(callFrame);
14502 auto& impl = castedThis->wrapped();
14503 if (UNLIKELY(callFrame->argumentCount() < 1))
14504 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14505 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14506 auto track = convert<IDLInterface<MediaStreamTrack>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "track", "Internals", "isMediaStreamSourceInterrupted", "MediaStreamTrack"); });
14507 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14508 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isMediaStreamSourceInterrupted(*track))));
14509}
14510
14511JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isMediaStreamSourceInterrupted, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14512{
14513 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isMediaStreamSourceInterruptedBody>(*lexicalGlobalObject, *callFrame, "isMediaStreamSourceInterrupted");
14514}
14515
14516#endif
14517
14518#if ENABLE(MEDIA_STREAM)
14519static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isMediaStreamSourceEndedBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14520{
14521 auto& vm = JSC::getVM(lexicalGlobalObject);
14522 auto throwScope = DECLARE_THROW_SCOPE(vm);
14523 UNUSED_PARAM(throwScope);
14524 UNUSED_PARAM(callFrame);
14525 auto& impl = castedThis->wrapped();
14526 if (UNLIKELY(callFrame->argumentCount() < 1))
14527 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14528 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14529 auto track = convert<IDLInterface<MediaStreamTrack>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "track", "Internals", "isMediaStreamSourceEnded", "MediaStreamTrack"); });
14530 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14531 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isMediaStreamSourceEnded(*track))));
14532}
14533
14534JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isMediaStreamSourceEnded, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14535{
14536 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isMediaStreamSourceEndedBody>(*lexicalGlobalObject, *callFrame, "isMediaStreamSourceEnded");
14537}
14538
14539#endif
14540
14541#if ENABLE(MEDIA_STREAM)
14542static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isMockRealtimeMediaSourceCenterEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14543{
14544 auto& vm = JSC::getVM(lexicalGlobalObject);
14545 auto throwScope = DECLARE_THROW_SCOPE(vm);
14546 UNUSED_PARAM(throwScope);
14547 UNUSED_PARAM(callFrame);
14548 auto& impl = castedThis->wrapped();
14549 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isMockRealtimeMediaSourceCenterEnabled())));
14550}
14551
14552JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isMockRealtimeMediaSourceCenterEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14553{
14554 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isMockRealtimeMediaSourceCenterEnabledBody>(*lexicalGlobalObject, *callFrame, "isMockRealtimeMediaSourceCenterEnabled");
14555}
14556
14557#endif
14558
14559#if ENABLE(MEDIA_STREAM)
14560static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_shouldAudioTrackPlayBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14561{
14562 auto& vm = JSC::getVM(lexicalGlobalObject);
14563 auto throwScope = DECLARE_THROW_SCOPE(vm);
14564 UNUSED_PARAM(throwScope);
14565 UNUSED_PARAM(callFrame);
14566 auto& impl = castedThis->wrapped();
14567 if (UNLIKELY(callFrame->argumentCount() < 1))
14568 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14569 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14570 auto track = convert<IDLInterface<AudioTrack>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "track", "Internals", "shouldAudioTrackPlay", "AudioTrack"); });
14571 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14572 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.shouldAudioTrackPlay(*track))));
14573}
14574
14575JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_shouldAudioTrackPlay, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14576{
14577 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_shouldAudioTrackPlayBody>(*lexicalGlobalObject, *callFrame, "shouldAudioTrackPlay");
14578}
14579
14580#endif
14581
14582static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_documentIdentifierBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14583{
14584 auto& vm = JSC::getVM(lexicalGlobalObject);
14585 auto throwScope = DECLARE_THROW_SCOPE(vm);
14586 UNUSED_PARAM(throwScope);
14587 UNUSED_PARAM(callFrame);
14588 auto& impl = castedThis->wrapped();
14589 if (UNLIKELY(callFrame->argumentCount() < 1))
14590 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14591 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14592 auto document = convert<IDLInterface<Document>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "document", "Internals", "documentIdentifier", "Document"); });
14593 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14594 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLongLong>(*lexicalGlobalObject, throwScope, impl.documentIdentifier(*document))));
14595}
14596
14597JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_documentIdentifier, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14598{
14599 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_documentIdentifierBody>(*lexicalGlobalObject, *callFrame, "documentIdentifier");
14600}
14601
14602static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isDocumentAliveBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14603{
14604 auto& vm = JSC::getVM(lexicalGlobalObject);
14605 auto throwScope = DECLARE_THROW_SCOPE(vm);
14606 UNUSED_PARAM(throwScope);
14607 UNUSED_PARAM(callFrame);
14608 auto& impl = castedThis->wrapped();
14609 if (UNLIKELY(callFrame->argumentCount() < 1))
14610 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14611 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14612 auto documentIdentifier = convert<IDLUnsignedLongLong>(*lexicalGlobalObject, argument0.value());
14613 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14614 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isDocumentAlive(WTFMove(documentIdentifier)))));
14615}
14616
14617JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isDocumentAlive, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14618{
14619 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isDocumentAliveBody>(*lexicalGlobalObject, *callFrame, "isDocumentAlive");
14620}
14621
14622static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_elementIdentifierBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14623{
14624 auto& vm = JSC::getVM(lexicalGlobalObject);
14625 auto throwScope = DECLARE_THROW_SCOPE(vm);
14626 UNUSED_PARAM(throwScope);
14627 UNUSED_PARAM(callFrame);
14628 auto& impl = castedThis->wrapped();
14629 if (UNLIKELY(callFrame->argumentCount() < 1))
14630 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14631 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14632 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "elementIdentifier", "Element"); });
14633 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14634 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLongLong>(*lexicalGlobalObject, throwScope, impl.elementIdentifier(*element))));
14635}
14636
14637JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_elementIdentifier, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14638{
14639 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_elementIdentifierBody>(*lexicalGlobalObject, *callFrame, "elementIdentifier");
14640}
14641
14642static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isElementAliveBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14643{
14644 auto& vm = JSC::getVM(lexicalGlobalObject);
14645 auto throwScope = DECLARE_THROW_SCOPE(vm);
14646 UNUSED_PARAM(throwScope);
14647 UNUSED_PARAM(callFrame);
14648 auto& impl = castedThis->wrapped();
14649 if (UNLIKELY(callFrame->argumentCount() < 1))
14650 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14651 auto* context = jsCast<JSDOMGlobalObject*>(lexicalGlobalObject)->scriptExecutionContext();
14652 if (UNLIKELY(!context))
14653 return JSValue::encode(jsUndefined());
14654 ASSERT(context->isDocument());
14655 auto& document = downcast<Document>(*context);
14656 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14657 auto documentIdentifier = convert<IDLUnsignedLongLong>(*lexicalGlobalObject, argument0.value());
14658 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14659 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isElementAlive(document, WTFMove(documentIdentifier)))));
14660}
14661
14662JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isElementAlive, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14663{
14664 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isElementAliveBody>(*lexicalGlobalObject, *callFrame, "isElementAlive");
14665}
14666
14667static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_frameIdentifierBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14668{
14669 auto& vm = JSC::getVM(lexicalGlobalObject);
14670 auto throwScope = DECLARE_THROW_SCOPE(vm);
14671 UNUSED_PARAM(throwScope);
14672 UNUSED_PARAM(callFrame);
14673 auto& impl = castedThis->wrapped();
14674 if (UNLIKELY(callFrame->argumentCount() < 1))
14675 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14676 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14677 auto document = convert<IDLInterface<Document>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "document", "Internals", "frameIdentifier", "Document"); });
14678 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14679 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLongLong>(*lexicalGlobalObject, throwScope, impl.frameIdentifier(*document))));
14680}
14681
14682JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_frameIdentifier, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14683{
14684 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_frameIdentifierBody>(*lexicalGlobalObject, *callFrame, "frameIdentifier");
14685}
14686
14687static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pageIdentifierBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14688{
14689 auto& vm = JSC::getVM(lexicalGlobalObject);
14690 auto throwScope = DECLARE_THROW_SCOPE(vm);
14691 UNUSED_PARAM(throwScope);
14692 UNUSED_PARAM(callFrame);
14693 auto& impl = castedThis->wrapped();
14694 if (UNLIKELY(callFrame->argumentCount() < 1))
14695 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14696 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14697 auto document = convert<IDLInterface<Document>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "document", "Internals", "pageIdentifier", "Document"); });
14698 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14699 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLongLong>(*lexicalGlobalObject, throwScope, impl.pageIdentifier(*document))));
14700}
14701
14702JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pageIdentifier, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14703{
14704 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pageIdentifierBody>(*lexicalGlobalObject, *callFrame, "pageIdentifier");
14705}
14706
14707static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isAnyWorkletGlobalScopeAliveBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14708{
14709 auto& vm = JSC::getVM(lexicalGlobalObject);
14710 auto throwScope = DECLARE_THROW_SCOPE(vm);
14711 UNUSED_PARAM(throwScope);
14712 UNUSED_PARAM(callFrame);
14713 auto& impl = castedThis->wrapped();
14714 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isAnyWorkletGlobalScopeAlive())));
14715}
14716
14717JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isAnyWorkletGlobalScopeAlive, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14718{
14719 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isAnyWorkletGlobalScopeAliveBody>(*lexicalGlobalObject, *callFrame, "isAnyWorkletGlobalScopeAlive");
14720}
14721
14722static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_serviceWorkerClientIdentifierBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14723{
14724 auto& vm = JSC::getVM(lexicalGlobalObject);
14725 auto throwScope = DECLARE_THROW_SCOPE(vm);
14726 UNUSED_PARAM(throwScope);
14727 UNUSED_PARAM(callFrame);
14728 auto& impl = castedThis->wrapped();
14729 if (UNLIKELY(callFrame->argumentCount() < 1))
14730 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14731 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14732 auto document = convert<IDLInterface<Document>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "document", "Internals", "serviceWorkerClientIdentifier", "Document"); });
14733 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14734 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.serviceWorkerClientIdentifier(*document))));
14735}
14736
14737JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_serviceWorkerClientIdentifier, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14738{
14739 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_serviceWorkerClientIdentifierBody>(*lexicalGlobalObject, *callFrame, "serviceWorkerClientIdentifier");
14740}
14741
14742static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_storeRegistrationsOnDiskBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
14743{
14744 auto& vm = JSC::getVM(lexicalGlobalObject);
14745 auto throwScope = DECLARE_THROW_SCOPE(vm);
14746 UNUSED_PARAM(throwScope);
14747 UNUSED_PARAM(callFrame);
14748 auto& impl = castedThis->wrapped();
14749 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLUndefined>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.storeRegistrationsOnDisk(WTFMove(promise)); })));
14750}
14751
14752JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_storeRegistrationsOnDisk, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14753{
14754 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunction_storeRegistrationsOnDiskBody>(*lexicalGlobalObject, *callFrame, "storeRegistrationsOnDisk");
14755}
14756
14757static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_sendH2PingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
14758{
14759 auto& vm = JSC::getVM(lexicalGlobalObject);
14760 auto throwScope = DECLARE_THROW_SCOPE(vm);
14761 UNUSED_PARAM(throwScope);
14762 UNUSED_PARAM(callFrame);
14763 auto& impl = castedThis->wrapped();
14764 if (UNLIKELY(callFrame->argumentCount() < 1))
14765 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14766 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14767 auto url = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
14768 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14769 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLDouble>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.sendH2Ping(WTFMove(url), WTFMove(promise)); })));
14770}
14771
14772JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_sendH2Ping, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14773{
14774 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunction_sendH2PingBody>(*lexicalGlobalObject, *callFrame, "sendH2Ping");
14775}
14776
14777static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_clearCacheStorageMemoryRepresentationBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
14778{
14779 auto& vm = JSC::getVM(lexicalGlobalObject);
14780 auto throwScope = DECLARE_THROW_SCOPE(vm);
14781 UNUSED_PARAM(throwScope);
14782 UNUSED_PARAM(callFrame);
14783 auto& impl = castedThis->wrapped();
14784 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLUndefined>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.clearCacheStorageMemoryRepresentation(WTFMove(promise)); })));
14785}
14786
14787JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_clearCacheStorageMemoryRepresentation, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14788{
14789 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunction_clearCacheStorageMemoryRepresentationBody>(*lexicalGlobalObject, *callFrame, "clearCacheStorageMemoryRepresentation");
14790}
14791
14792static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_cacheStorageEngineRepresentationBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
14793{
14794 auto& vm = JSC::getVM(lexicalGlobalObject);
14795 auto throwScope = DECLARE_THROW_SCOPE(vm);
14796 UNUSED_PARAM(throwScope);
14797 UNUSED_PARAM(callFrame);
14798 auto& impl = castedThis->wrapped();
14799 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLDOMString>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.cacheStorageEngineRepresentation(WTFMove(promise)); })));
14800}
14801
14802JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_cacheStorageEngineRepresentation, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14803{
14804 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunction_cacheStorageEngineRepresentationBody>(*lexicalGlobalObject, *callFrame, "cacheStorageEngineRepresentation");
14805}
14806
14807static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setResponseSizeWithPaddingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14808{
14809 auto& vm = JSC::getVM(lexicalGlobalObject);
14810 auto throwScope = DECLARE_THROW_SCOPE(vm);
14811 UNUSED_PARAM(throwScope);
14812 UNUSED_PARAM(callFrame);
14813 auto& impl = castedThis->wrapped();
14814 if (UNLIKELY(callFrame->argumentCount() < 2))
14815 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14816 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14817 auto response = convert<IDLInterface<FetchResponse>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "response", "Internals", "setResponseSizeWithPadding", "FetchResponse"); });
14818 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14819 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
14820 auto size = convert<IDLUnsignedLongLong>(*lexicalGlobalObject, argument1.value());
14821 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14822 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setResponseSizeWithPadding(*response, WTFMove(size)); })));
14823}
14824
14825JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setResponseSizeWithPadding, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14826{
14827 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setResponseSizeWithPaddingBody>(*lexicalGlobalObject, *callFrame, "setResponseSizeWithPadding");
14828}
14829
14830static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_responseSizeWithPaddingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14831{
14832 auto& vm = JSC::getVM(lexicalGlobalObject);
14833 auto throwScope = DECLARE_THROW_SCOPE(vm);
14834 UNUSED_PARAM(throwScope);
14835 UNUSED_PARAM(callFrame);
14836 auto& impl = castedThis->wrapped();
14837 if (UNLIKELY(callFrame->argumentCount() < 1))
14838 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14839 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14840 auto response = convert<IDLInterface<FetchResponse>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "response", "Internals", "responseSizeWithPadding", "FetchResponse"); });
14841 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14842 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLongLong>(*lexicalGlobalObject, throwScope, impl.responseSizeWithPadding(*response))));
14843}
14844
14845JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_responseSizeWithPadding, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14846{
14847 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_responseSizeWithPaddingBody>(*lexicalGlobalObject, *callFrame, "responseSizeWithPadding");
14848}
14849
14850static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_updateQuotaBasedOnSpaceUsageBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14851{
14852 auto& vm = JSC::getVM(lexicalGlobalObject);
14853 auto throwScope = DECLARE_THROW_SCOPE(vm);
14854 UNUSED_PARAM(throwScope);
14855 UNUSED_PARAM(callFrame);
14856 auto& impl = castedThis->wrapped();
14857 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.updateQuotaBasedOnSpaceUsage(); })));
14858}
14859
14860JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_updateQuotaBasedOnSpaceUsage, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14861{
14862 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_updateQuotaBasedOnSpaceUsageBody>(*lexicalGlobalObject, *callFrame, "updateQuotaBasedOnSpaceUsage");
14863}
14864
14865static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setConsoleMessageListenerBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14866{
14867 auto& vm = JSC::getVM(lexicalGlobalObject);
14868 auto throwScope = DECLARE_THROW_SCOPE(vm);
14869 UNUSED_PARAM(throwScope);
14870 UNUSED_PARAM(callFrame);
14871 auto& impl = castedThis->wrapped();
14872 if (UNLIKELY(callFrame->argumentCount() < 1))
14873 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14874 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14875 auto callback = convert<IDLCallbackFunction<JSStringCallback>>(*lexicalGlobalObject, argument0.value(), *castedThis->globalObject(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(lexicalGlobalObject, scope, 0, "callback", "Internals", "setConsoleMessageListener"); });
14876 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14877 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setConsoleMessageListener(callback.releaseNonNull()); })));
14878}
14879
14880JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setConsoleMessageListener, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14881{
14882 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setConsoleMessageListenerBody>(*lexicalGlobalObject, *callFrame, "setConsoleMessageListener");
14883}
14884
14885static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_audioSessionCategoryBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14886{
14887 auto& vm = JSC::getVM(lexicalGlobalObject);
14888 auto throwScope = DECLARE_THROW_SCOPE(vm);
14889 UNUSED_PARAM(throwScope);
14890 UNUSED_PARAM(callFrame);
14891 auto& impl = castedThis->wrapped();
14892 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.audioSessionCategory())));
14893}
14894
14895JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_audioSessionCategory, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14896{
14897 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_audioSessionCategoryBody>(*lexicalGlobalObject, *callFrame, "audioSessionCategory");
14898}
14899
14900static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_preferredAudioBufferSizeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14901{
14902 auto& vm = JSC::getVM(lexicalGlobalObject);
14903 auto throwScope = DECLARE_THROW_SCOPE(vm);
14904 UNUSED_PARAM(throwScope);
14905 UNUSED_PARAM(callFrame);
14906 auto& impl = castedThis->wrapped();
14907 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.preferredAudioBufferSize())));
14908}
14909
14910JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_preferredAudioBufferSize, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14911{
14912 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_preferredAudioBufferSizeBody>(*lexicalGlobalObject, *callFrame, "preferredAudioBufferSize");
14913}
14914
14915static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_currentAudioBufferSizeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14916{
14917 auto& vm = JSC::getVM(lexicalGlobalObject);
14918 auto throwScope = DECLARE_THROW_SCOPE(vm);
14919 UNUSED_PARAM(throwScope);
14920 UNUSED_PARAM(callFrame);
14921 auto& impl = castedThis->wrapped();
14922 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.currentAudioBufferSize())));
14923}
14924
14925JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_currentAudioBufferSize, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14926{
14927 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_currentAudioBufferSizeBody>(*lexicalGlobalObject, *callFrame, "currentAudioBufferSize");
14928}
14929
14930static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_audioSessionActiveBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
14931{
14932 auto& vm = JSC::getVM(lexicalGlobalObject);
14933 auto throwScope = DECLARE_THROW_SCOPE(vm);
14934 UNUSED_PARAM(throwScope);
14935 UNUSED_PARAM(callFrame);
14936 auto& impl = castedThis->wrapped();
14937 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.audioSessionActive())));
14938}
14939
14940JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_audioSessionActive, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14941{
14942 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_audioSessionActiveBody>(*lexicalGlobalObject, *callFrame, "audioSessionActive");
14943}
14944
14945#if ENABLE(SERVICE_WORKER)
14946static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_hasServiceWorkerRegistrationBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
14947{
14948 auto& vm = JSC::getVM(lexicalGlobalObject);
14949 auto throwScope = DECLARE_THROW_SCOPE(vm);
14950 UNUSED_PARAM(throwScope);
14951 UNUSED_PARAM(callFrame);
14952 auto& impl = castedThis->wrapped();
14953 if (UNLIKELY(callFrame->argumentCount() < 1))
14954 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14955 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14956 auto scopeURL = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
14957 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14958 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLBoolean>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.hasServiceWorkerRegistration(WTFMove(scopeURL), WTFMove(promise)); })));
14959}
14960
14961JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasServiceWorkerRegistration, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14962{
14963 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunction_hasServiceWorkerRegistrationBody>(*lexicalGlobalObject, *callFrame, "hasServiceWorkerRegistration");
14964}
14965
14966#endif
14967
14968#if ENABLE(SERVICE_WORKER)
14969static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_terminateServiceWorkerBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
14970{
14971 auto& vm = JSC::getVM(lexicalGlobalObject);
14972 auto throwScope = DECLARE_THROW_SCOPE(vm);
14973 UNUSED_PARAM(throwScope);
14974 UNUSED_PARAM(callFrame);
14975 auto& impl = castedThis->wrapped();
14976 if (UNLIKELY(callFrame->argumentCount() < 1))
14977 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
14978 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
14979 auto worker = convert<IDLInterface<ServiceWorker>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "worker", "Internals", "terminateServiceWorker", "ServiceWorker"); });
14980 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
14981 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLUndefined>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.terminateServiceWorker(*worker, WTFMove(promise)); })));
14982}
14983
14984JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_terminateServiceWorker, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
14985{
14986 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunction_terminateServiceWorkerBody>(*lexicalGlobalObject, *callFrame, "terminateServiceWorker");
14987}
14988
14989#endif
14990
14991#if ENABLE(SERVICE_WORKER)
14992static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_whenServiceWorkerIsTerminatedBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
14993{
14994 auto& vm = JSC::getVM(lexicalGlobalObject);
14995 auto throwScope = DECLARE_THROW_SCOPE(vm);
14996 UNUSED_PARAM(throwScope);
14997 UNUSED_PARAM(callFrame);
14998 auto& impl = castedThis->wrapped();
14999 if (UNLIKELY(callFrame->argumentCount() < 1))
15000 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15001 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15002 auto worker = convert<IDLInterface<ServiceWorker>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "worker", "Internals", "whenServiceWorkerIsTerminated", "ServiceWorker"); });
15003 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15004 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLUndefined>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.whenServiceWorkerIsTerminated(*worker, WTFMove(promise)); })));
15005}
15006
15007JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_whenServiceWorkerIsTerminated, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15008{
15009 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunction_whenServiceWorkerIsTerminatedBody>(*lexicalGlobalObject, *callFrame, "whenServiceWorkerIsTerminated");
15010}
15011
15012#endif
15013
15014static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isSystemPreviewLinkBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15015{
15016 auto& vm = JSC::getVM(lexicalGlobalObject);
15017 auto throwScope = DECLARE_THROW_SCOPE(vm);
15018 UNUSED_PARAM(throwScope);
15019 UNUSED_PARAM(callFrame);
15020 auto& impl = castedThis->wrapped();
15021 if (UNLIKELY(callFrame->argumentCount() < 1))
15022 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15023 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15024 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "isSystemPreviewLink", "Element"); });
15025 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15026 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isSystemPreviewLink(*element))));
15027}
15028
15029JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isSystemPreviewLink, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15030{
15031 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isSystemPreviewLinkBody>(*lexicalGlobalObject, *callFrame, "isSystemPreviewLink");
15032}
15033
15034static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isSystemPreviewImageBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15035{
15036 auto& vm = JSC::getVM(lexicalGlobalObject);
15037 auto throwScope = DECLARE_THROW_SCOPE(vm);
15038 UNUSED_PARAM(throwScope);
15039 UNUSED_PARAM(callFrame);
15040 auto& impl = castedThis->wrapped();
15041 if (UNLIKELY(callFrame->argumentCount() < 1))
15042 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15043 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15044 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "isSystemPreviewImage", "Element"); });
15045 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15046 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isSystemPreviewImage(*element))));
15047}
15048
15049JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isSystemPreviewImage, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15050{
15051 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isSystemPreviewImageBody>(*lexicalGlobalObject, *callFrame, "isSystemPreviewImage");
15052}
15053
15054static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_installImageOverlayBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15055{
15056 auto& vm = JSC::getVM(lexicalGlobalObject);
15057 auto throwScope = DECLARE_THROW_SCOPE(vm);
15058 UNUSED_PARAM(throwScope);
15059 UNUSED_PARAM(callFrame);
15060 auto& impl = castedThis->wrapped();
15061 if (UNLIKELY(callFrame->argumentCount() < 2))
15062 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15063 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15064 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "installImageOverlay", "Element"); });
15065 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15066 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
15067 auto lines = convert<IDLSequence<IDLDictionary<Internals::ImageOverlayLine>>>(*lexicalGlobalObject, argument1.value());
15068 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15069 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.installImageOverlay(*element, WTFMove(lines)); })));
15070}
15071
15072JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_installImageOverlay, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15073{
15074 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_installImageOverlayBody>(*lexicalGlobalObject, *callFrame, "installImageOverlay");
15075}
15076
15077static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_usingAppleInternalSDKBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15078{
15079 auto& vm = JSC::getVM(lexicalGlobalObject);
15080 auto throwScope = DECLARE_THROW_SCOPE(vm);
15081 UNUSED_PARAM(throwScope);
15082 UNUSED_PARAM(callFrame);
15083 auto& impl = castedThis->wrapped();
15084 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.usingAppleInternalSDK())));
15085}
15086
15087JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_usingAppleInternalSDK, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15088{
15089 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_usingAppleInternalSDKBody>(*lexicalGlobalObject, *callFrame, "usingAppleInternalSDK");
15090}
15091
15092static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_usingGStreamerBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15093{
15094 auto& vm = JSC::getVM(lexicalGlobalObject);
15095 auto throwScope = DECLARE_THROW_SCOPE(vm);
15096 UNUSED_PARAM(throwScope);
15097 UNUSED_PARAM(callFrame);
15098 auto& impl = castedThis->wrapped();
15099 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.usingGStreamer())));
15100}
15101
15102JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_usingGStreamer, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15103{
15104 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_usingGStreamerBody>(*lexicalGlobalObject, *callFrame, "usingGStreamer");
15105}
15106
15107static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_postTaskBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15108{
15109 auto& vm = JSC::getVM(lexicalGlobalObject);
15110 auto throwScope = DECLARE_THROW_SCOPE(vm);
15111 UNUSED_PARAM(throwScope);
15112 UNUSED_PARAM(callFrame);
15113 auto& impl = castedThis->wrapped();
15114 if (UNLIKELY(callFrame->argumentCount() < 1))
15115 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15116 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15117 auto callback = convert<IDLCallbackFunction<JSVoidCallback>>(*lexicalGlobalObject, argument0.value(), *castedThis->globalObject(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(lexicalGlobalObject, scope, 0, "callback", "Internals", "postTask"); });
15118 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15119 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.postTask(callback.releaseNonNull()); })));
15120}
15121
15122JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_postTask, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15123{
15124 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_postTaskBody>(*lexicalGlobalObject, *callFrame, "postTask");
15125}
15126
15127static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_queueTaskBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15128{
15129 auto& vm = JSC::getVM(lexicalGlobalObject);
15130 auto throwScope = DECLARE_THROW_SCOPE(vm);
15131 UNUSED_PARAM(throwScope);
15132 UNUSED_PARAM(callFrame);
15133 auto& impl = castedThis->wrapped();
15134 if (UNLIKELY(callFrame->argumentCount() < 2))
15135 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15136 auto* context = jsCast<JSDOMGlobalObject*>(lexicalGlobalObject)->scriptExecutionContext();
15137 if (UNLIKELY(!context))
15138 return JSValue::encode(jsUndefined());
15139 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15140 auto source = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
15141 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15142 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
15143 auto callback = convert<IDLCallbackFunction<JSVoidCallback>>(*lexicalGlobalObject, argument1.value(), *castedThis->globalObject(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(lexicalGlobalObject, scope, 1, "callback", "Internals", "queueTask"); });
15144 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15145 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.queueTask(*context, WTFMove(source), callback.releaseNonNull()); })));
15146}
15147
15148JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_queueTask, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15149{
15150 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_queueTaskBody>(*lexicalGlobalObject, *callFrame, "queueTask");
15151}
15152
15153static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_queueTaskToQueueMicrotaskBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15154{
15155 auto& vm = JSC::getVM(lexicalGlobalObject);
15156 auto throwScope = DECLARE_THROW_SCOPE(vm);
15157 UNUSED_PARAM(throwScope);
15158 UNUSED_PARAM(callFrame);
15159 auto& impl = castedThis->wrapped();
15160 if (UNLIKELY(callFrame->argumentCount() < 2))
15161 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15162 auto* context = jsCast<JSDOMGlobalObject*>(lexicalGlobalObject)->scriptExecutionContext();
15163 if (UNLIKELY(!context))
15164 return JSValue::encode(jsUndefined());
15165 ASSERT(context->isDocument());
15166 auto& document = downcast<Document>(*context);
15167 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15168 auto source = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
15169 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15170 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
15171 auto callback = convert<IDLCallbackFunction<JSVoidCallback>>(*lexicalGlobalObject, argument1.value(), *castedThis->globalObject(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(lexicalGlobalObject, scope, 1, "callback", "Internals", "queueTaskToQueueMicrotask"); });
15172 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15173 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.queueTaskToQueueMicrotask(document, WTFMove(source), callback.releaseNonNull()); })));
15174}
15175
15176JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_queueTaskToQueueMicrotask, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15177{
15178 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_queueTaskToQueueMicrotaskBody>(*lexicalGlobalObject, *callFrame, "queueTaskToQueueMicrotask");
15179}
15180
15181static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_hasSameEventLoopAsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15182{
15183 auto& vm = JSC::getVM(lexicalGlobalObject);
15184 auto throwScope = DECLARE_THROW_SCOPE(vm);
15185 UNUSED_PARAM(throwScope);
15186 UNUSED_PARAM(callFrame);
15187 auto& impl = castedThis->wrapped();
15188 if (UNLIKELY(callFrame->argumentCount() < 1))
15189 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15190 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15191 auto windowProxy = convert<IDLInterface<WindowProxy>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "windowProxy", "Internals", "hasSameEventLoopAs", "WindowProxy"); });
15192 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15193 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.hasSameEventLoopAs(*windowProxy))));
15194}
15195
15196JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasSameEventLoopAs, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15197{
15198 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_hasSameEventLoopAsBody>(*lexicalGlobalObject, *callFrame, "hasSameEventLoopAs");
15199}
15200
15201static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_windowLocationHostBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15202{
15203 auto& vm = JSC::getVM(lexicalGlobalObject);
15204 auto throwScope = DECLARE_THROW_SCOPE(vm);
15205 UNUSED_PARAM(throwScope);
15206 UNUSED_PARAM(callFrame);
15207 auto& impl = castedThis->wrapped();
15208 if (UNLIKELY(callFrame->argumentCount() < 1))
15209 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15210 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15211 auto window = convert<IDLInterface<DOMWindow>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "window", "Internals", "windowLocationHost", "DOMWindow"); });
15212 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15213 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.windowLocationHost(*window))));
15214}
15215
15216JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_windowLocationHost, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15217{
15218 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_windowLocationHostBody>(*lexicalGlobalObject, *callFrame, "windowLocationHost");
15219}
15220
15221static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_markContextAsInsecureBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15222{
15223 auto& vm = JSC::getVM(lexicalGlobalObject);
15224 auto throwScope = DECLARE_THROW_SCOPE(vm);
15225 UNUSED_PARAM(throwScope);
15226 UNUSED_PARAM(callFrame);
15227 auto& impl = castedThis->wrapped();
15228 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.markContextAsInsecure(); })));
15229}
15230
15231JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_markContextAsInsecure, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15232{
15233 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_markContextAsInsecureBody>(*lexicalGlobalObject, *callFrame, "markContextAsInsecure");
15234}
15235
15236static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMaxCanvasPixelMemoryBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15237{
15238 auto& vm = JSC::getVM(lexicalGlobalObject);
15239 auto throwScope = DECLARE_THROW_SCOPE(vm);
15240 UNUSED_PARAM(throwScope);
15241 UNUSED_PARAM(callFrame);
15242 auto& impl = castedThis->wrapped();
15243 if (UNLIKELY(callFrame->argumentCount() < 1))
15244 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15245 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15246 auto size = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument0.value());
15247 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15248 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMaxCanvasPixelMemory(WTFMove(size)); })));
15249}
15250
15251JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMaxCanvasPixelMemory, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15252{
15253 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMaxCanvasPixelMemoryBody>(*lexicalGlobalObject, *callFrame, "setMaxCanvasPixelMemory");
15254}
15255
15256#if ENABLE(VIDEO)
15257static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_bestMediaElementForRemoteControlsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15258{
15259 auto& vm = JSC::getVM(lexicalGlobalObject);
15260 auto throwScope = DECLARE_THROW_SCOPE(vm);
15261 UNUSED_PARAM(throwScope);
15262 UNUSED_PARAM(callFrame);
15263 auto& impl = castedThis->wrapped();
15264 if (UNLIKELY(callFrame->argumentCount() < 1))
15265 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15266 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15267 auto purpose = convert<IDLEnumeration<Internals::PlaybackControlsPurpose>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 0, "purpose", "Internals", "bestMediaElementForRemoteControls", expectedEnumerationValues<Internals::PlaybackControlsPurpose>()); });
15268 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15269 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.bestMediaElementForRemoteControls(WTFMove(purpose)))));
15270}
15271
15272JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_bestMediaElementForRemoteControls, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15273{
15274 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_bestMediaElementForRemoteControlsBody>(*lexicalGlobalObject, *callFrame, "bestMediaElementForRemoteControls");
15275}
15276
15277#endif
15278
15279#if ENABLE(VIDEO)
15280static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_mediaSessionStateBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15281{
15282 auto& vm = JSC::getVM(lexicalGlobalObject);
15283 auto throwScope = DECLARE_THROW_SCOPE(vm);
15284 UNUSED_PARAM(throwScope);
15285 UNUSED_PARAM(callFrame);
15286 auto& impl = castedThis->wrapped();
15287 if (UNLIKELY(callFrame->argumentCount() < 1))
15288 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15289 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15290 auto element = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "mediaSessionState", "HTMLMediaElement"); });
15291 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15292 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLEnumeration<Internals::MediaSessionState>>(*lexicalGlobalObject, throwScope, impl.mediaSessionState(*element))));
15293}
15294
15295JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaSessionState, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15296{
15297 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_mediaSessionStateBody>(*lexicalGlobalObject, *callFrame, "mediaSessionState");
15298}
15299
15300#endif
15301
15302#if ENABLE(VIDEO)
15303static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_mediaUsageStateBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15304{
15305 auto& vm = JSC::getVM(lexicalGlobalObject);
15306 auto throwScope = DECLARE_THROW_SCOPE(vm);
15307 UNUSED_PARAM(throwScope);
15308 UNUSED_PARAM(callFrame);
15309 auto& impl = castedThis->wrapped();
15310 if (UNLIKELY(callFrame->argumentCount() < 1))
15311 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15312 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15313 auto element = convert<IDLInterface<HTMLMediaElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "mediaUsageState", "HTMLMediaElement"); });
15314 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15315 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDictionary<Internals::MediaUsageState>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.mediaUsageState(*element))));
15316}
15317
15318JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaUsageState, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15319{
15320 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_mediaUsageStateBody>(*lexicalGlobalObject, *callFrame, "mediaUsageState");
15321}
15322
15323#endif
15324
15325#if ENABLE(VIDEO)
15326static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_elementShouldDisplayPosterImageBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15327{
15328 auto& vm = JSC::getVM(lexicalGlobalObject);
15329 auto throwScope = DECLARE_THROW_SCOPE(vm);
15330 UNUSED_PARAM(throwScope);
15331 UNUSED_PARAM(callFrame);
15332 auto& impl = castedThis->wrapped();
15333 if (UNLIKELY(callFrame->argumentCount() < 1))
15334 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15335 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15336 auto element = convert<IDLInterface<HTMLVideoElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "elementShouldDisplayPosterImage", "HTMLVideoElement"); });
15337 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15338 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.elementShouldDisplayPosterImage(*element))));
15339}
15340
15341JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_elementShouldDisplayPosterImage, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15342{
15343 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_elementShouldDisplayPosterImageBody>(*lexicalGlobalObject, *callFrame, "elementShouldDisplayPosterImage");
15344}
15345
15346#endif
15347
15348static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_ongoingLoadsDescriptionsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15349{
15350 auto& vm = JSC::getVM(lexicalGlobalObject);
15351 auto throwScope = DECLARE_THROW_SCOPE(vm);
15352 UNUSED_PARAM(throwScope);
15353 UNUSED_PARAM(callFrame);
15354 auto& impl = castedThis->wrapped();
15355 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.ongoingLoadsDescriptions())));
15356}
15357
15358JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_ongoingLoadsDescriptions, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15359{
15360 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_ongoingLoadsDescriptionsBody>(*lexicalGlobalObject, *callFrame, "ongoingLoadsDescriptions");
15361}
15362
15363static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setCaptureExtraNetworkLoadMetricsEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15364{
15365 auto& vm = JSC::getVM(lexicalGlobalObject);
15366 auto throwScope = DECLARE_THROW_SCOPE(vm);
15367 UNUSED_PARAM(throwScope);
15368 UNUSED_PARAM(callFrame);
15369 auto& impl = castedThis->wrapped();
15370 if (UNLIKELY(callFrame->argumentCount() < 1))
15371 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15372 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15373 auto value = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
15374 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15375 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setCaptureExtraNetworkLoadMetricsEnabled(WTFMove(value)); })));
15376}
15377
15378JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setCaptureExtraNetworkLoadMetricsEnabled, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15379{
15380 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setCaptureExtraNetworkLoadMetricsEnabledBody>(*lexicalGlobalObject, *callFrame, "setCaptureExtraNetworkLoadMetricsEnabled");
15381}
15382
15383static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_reloadWithoutContentExtensionsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15384{
15385 auto& vm = JSC::getVM(lexicalGlobalObject);
15386 auto throwScope = DECLARE_THROW_SCOPE(vm);
15387 UNUSED_PARAM(throwScope);
15388 UNUSED_PARAM(callFrame);
15389 auto& impl = castedThis->wrapped();
15390 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.reloadWithoutContentExtensions(); })));
15391}
15392
15393JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_reloadWithoutContentExtensions, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15394{
15395 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_reloadWithoutContentExtensionsBody>(*lexicalGlobalObject, *callFrame, "reloadWithoutContentExtensions");
15396}
15397
15398static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setUseSystemAppearanceBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15399{
15400 auto& vm = JSC::getVM(lexicalGlobalObject);
15401 auto throwScope = DECLARE_THROW_SCOPE(vm);
15402 UNUSED_PARAM(throwScope);
15403 UNUSED_PARAM(callFrame);
15404 auto& impl = castedThis->wrapped();
15405 if (UNLIKELY(callFrame->argumentCount() < 1))
15406 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15407 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15408 auto value = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
15409 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15410 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setUseSystemAppearance(WTFMove(value)); })));
15411}
15412
15413JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setUseSystemAppearance, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15414{
15415 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setUseSystemAppearanceBody>(*lexicalGlobalObject, *callFrame, "setUseSystemAppearance");
15416}
15417
15418static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_pluginCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15419{
15420 auto& vm = JSC::getVM(lexicalGlobalObject);
15421 auto throwScope = DECLARE_THROW_SCOPE(vm);
15422 UNUSED_PARAM(throwScope);
15423 UNUSED_PARAM(callFrame);
15424 auto& impl = castedThis->wrapped();
15425 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.pluginCount())));
15426}
15427
15428JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_pluginCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15429{
15430 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_pluginCountBody>(*lexicalGlobalObject, *callFrame, "pluginCount");
15431}
15432
15433static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_notifyResourceLoadObserverBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15434{
15435 auto& vm = JSC::getVM(lexicalGlobalObject);
15436 auto throwScope = DECLARE_THROW_SCOPE(vm);
15437 UNUSED_PARAM(throwScope);
15438 UNUSED_PARAM(callFrame);
15439 auto& impl = castedThis->wrapped();
15440 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.notifyResourceLoadObserver(); })));
15441}
15442
15443JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_notifyResourceLoadObserver, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15444{
15445 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_notifyResourceLoadObserverBody>(*lexicalGlobalObject, *callFrame, "notifyResourceLoadObserver");
15446}
15447
15448static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_primaryScreenDisplayIDBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15449{
15450 auto& vm = JSC::getVM(lexicalGlobalObject);
15451 auto throwScope = DECLARE_THROW_SCOPE(vm);
15452 UNUSED_PARAM(throwScope);
15453 UNUSED_PARAM(callFrame);
15454 auto& impl = castedThis->wrapped();
15455 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.primaryScreenDisplayID())));
15456}
15457
15458JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_primaryScreenDisplayID, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15459{
15460 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_primaryScreenDisplayIDBody>(*lexicalGlobalObject, *callFrame, "primaryScreenDisplayID");
15461}
15462
15463static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_capsLockIsOnBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15464{
15465 auto& vm = JSC::getVM(lexicalGlobalObject);
15466 auto throwScope = DECLARE_THROW_SCOPE(vm);
15467 UNUSED_PARAM(throwScope);
15468 UNUSED_PARAM(callFrame);
15469 auto& impl = castedThis->wrapped();
15470 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.capsLockIsOn())));
15471}
15472
15473JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_capsLockIsOn, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15474{
15475 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_capsLockIsOnBody>(*lexicalGlobalObject, *callFrame, "capsLockIsOn");
15476}
15477
15478static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_parseHEVCCodecParametersBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15479{
15480 auto& vm = JSC::getVM(lexicalGlobalObject);
15481 auto throwScope = DECLARE_THROW_SCOPE(vm);
15482 UNUSED_PARAM(throwScope);
15483 UNUSED_PARAM(callFrame);
15484 auto& impl = castedThis->wrapped();
15485 if (UNLIKELY(callFrame->argumentCount() < 1))
15486 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15487 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15488 auto codecParameters = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
15489 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15490 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLDictionary<Internals::HEVCParameterSet>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.parseHEVCCodecParameters(WTFMove(codecParameters)))));
15491}
15492
15493JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_parseHEVCCodecParameters, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15494{
15495 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_parseHEVCCodecParametersBody>(*lexicalGlobalObject, *callFrame, "parseHEVCCodecParameters");
15496}
15497
15498static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_parseDoViCodecParametersBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15499{
15500 auto& vm = JSC::getVM(lexicalGlobalObject);
15501 auto throwScope = DECLARE_THROW_SCOPE(vm);
15502 UNUSED_PARAM(throwScope);
15503 UNUSED_PARAM(callFrame);
15504 auto& impl = castedThis->wrapped();
15505 if (UNLIKELY(callFrame->argumentCount() < 1))
15506 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15507 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15508 auto codecParameters = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
15509 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15510 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLDictionary<Internals::DoViParameterSet>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.parseDoViCodecParameters(WTFMove(codecParameters)))));
15511}
15512
15513JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_parseDoViCodecParameters, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15514{
15515 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_parseDoViCodecParametersBody>(*lexicalGlobalObject, *callFrame, "parseDoViCodecParameters");
15516}
15517
15518static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_parseVPCodecParametersBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15519{
15520 auto& vm = JSC::getVM(lexicalGlobalObject);
15521 auto throwScope = DECLARE_THROW_SCOPE(vm);
15522 UNUSED_PARAM(throwScope);
15523 UNUSED_PARAM(callFrame);
15524 auto& impl = castedThis->wrapped();
15525 if (UNLIKELY(callFrame->argumentCount() < 1))
15526 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15527 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15528 auto codecParameters = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
15529 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15530 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLDictionary<Internals::VPCodecConfigurationRecord>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.parseVPCodecParameters(WTFMove(codecParameters)))));
15531}
15532
15533JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_parseVPCodecParameters, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15534{
15535 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_parseVPCodecParametersBody>(*lexicalGlobalObject, *callFrame, "parseVPCodecParameters");
15536}
15537
15538static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_getCookiesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15539{
15540 auto& vm = JSC::getVM(lexicalGlobalObject);
15541 auto throwScope = DECLARE_THROW_SCOPE(vm);
15542 UNUSED_PARAM(throwScope);
15543 UNUSED_PARAM(callFrame);
15544 auto& impl = castedThis->wrapped();
15545 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLSequence<IDLDictionary<Internals::CookieData>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.getCookies())));
15546}
15547
15548JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_getCookies, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15549{
15550 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_getCookiesBody>(*lexicalGlobalObject, *callFrame, "getCookies");
15551}
15552
15553static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setAlwaysAllowLocalWebarchiveBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15554{
15555 auto& vm = JSC::getVM(lexicalGlobalObject);
15556 auto throwScope = DECLARE_THROW_SCOPE(vm);
15557 UNUSED_PARAM(throwScope);
15558 UNUSED_PARAM(callFrame);
15559 auto& impl = castedThis->wrapped();
15560 if (UNLIKELY(callFrame->argumentCount() < 1))
15561 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15562 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15563 auto alwaysAllowLocalWebarchive = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
15564 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15565 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setAlwaysAllowLocalWebarchive(WTFMove(alwaysAllowLocalWebarchive)); })));
15566}
15567
15568JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setAlwaysAllowLocalWebarchive, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15569{
15570 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setAlwaysAllowLocalWebarchiveBody>(*lexicalGlobalObject, *callFrame, "setAlwaysAllowLocalWebarchive");
15571}
15572
15573static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_processWillSuspendBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15574{
15575 auto& vm = JSC::getVM(lexicalGlobalObject);
15576 auto throwScope = DECLARE_THROW_SCOPE(vm);
15577 UNUSED_PARAM(throwScope);
15578 UNUSED_PARAM(callFrame);
15579 auto& impl = castedThis->wrapped();
15580 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.processWillSuspend(); })));
15581}
15582
15583JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_processWillSuspend, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15584{
15585 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_processWillSuspendBody>(*lexicalGlobalObject, *callFrame, "processWillSuspend");
15586}
15587
15588static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_processDidResumeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15589{
15590 auto& vm = JSC::getVM(lexicalGlobalObject);
15591 auto throwScope = DECLARE_THROW_SCOPE(vm);
15592 UNUSED_PARAM(throwScope);
15593 UNUSED_PARAM(callFrame);
15594 auto& impl = castedThis->wrapped();
15595 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.processDidResume(); })));
15596}
15597
15598JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_processDidResume, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15599{
15600 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_processDidResumeBody>(*lexicalGlobalObject, *callFrame, "processDidResume");
15601}
15602
15603static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_testDictionaryLoggingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15604{
15605 auto& vm = JSC::getVM(lexicalGlobalObject);
15606 auto throwScope = DECLARE_THROW_SCOPE(vm);
15607 UNUSED_PARAM(throwScope);
15608 UNUSED_PARAM(callFrame);
15609 auto& impl = castedThis->wrapped();
15610 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.testDictionaryLogging(); })));
15611}
15612
15613JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_testDictionaryLogging, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15614{
15615 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_testDictionaryLoggingBody>(*lexicalGlobalObject, *callFrame, "testDictionaryLogging");
15616}
15617
15618static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMaximumIntervalForUserGestureForwardingForFetchBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15619{
15620 auto& vm = JSC::getVM(lexicalGlobalObject);
15621 auto throwScope = DECLARE_THROW_SCOPE(vm);
15622 UNUSED_PARAM(throwScope);
15623 UNUSED_PARAM(callFrame);
15624 auto& impl = castedThis->wrapped();
15625 if (UNLIKELY(callFrame->argumentCount() < 1))
15626 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15627 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15628 auto interval = convert<IDLDouble>(*lexicalGlobalObject, argument0.value());
15629 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15630 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMaximumIntervalForUserGestureForwardingForFetch(WTFMove(interval)); })));
15631}
15632
15633JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMaximumIntervalForUserGestureForwardingForFetch, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15634{
15635 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMaximumIntervalForUserGestureForwardingForFetchBody>(*lexicalGlobalObject, *callFrame, "setMaximumIntervalForUserGestureForwardingForFetch");
15636}
15637
15638static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setTransientActivationDurationBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15639{
15640 auto& vm = JSC::getVM(lexicalGlobalObject);
15641 auto throwScope = DECLARE_THROW_SCOPE(vm);
15642 UNUSED_PARAM(throwScope);
15643 UNUSED_PARAM(callFrame);
15644 auto& impl = castedThis->wrapped();
15645 if (UNLIKELY(callFrame->argumentCount() < 1))
15646 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15647 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15648 auto seconds = convert<IDLDouble>(*lexicalGlobalObject, argument0.value());
15649 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15650 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setTransientActivationDuration(WTFMove(seconds)); })));
15651}
15652
15653JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setTransientActivationDuration, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15654{
15655 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setTransientActivationDurationBody>(*lexicalGlobalObject, *callFrame, "setTransientActivationDuration");
15656}
15657
15658static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setIsPlayingToAutomotiveHeadUnitBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15659{
15660 auto& vm = JSC::getVM(lexicalGlobalObject);
15661 auto throwScope = DECLARE_THROW_SCOPE(vm);
15662 UNUSED_PARAM(throwScope);
15663 UNUSED_PARAM(callFrame);
15664 auto& impl = castedThis->wrapped();
15665 if (UNLIKELY(callFrame->argumentCount() < 1))
15666 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15667 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15668 auto value = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
15669 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15670 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setIsPlayingToAutomotiveHeadUnit(WTFMove(value)); })));
15671}
15672
15673JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setIsPlayingToAutomotiveHeadUnit, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15674{
15675 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setIsPlayingToAutomotiveHeadUnitBody>(*lexicalGlobalObject, *callFrame, "setIsPlayingToAutomotiveHeadUnit");
15676}
15677
15678static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_textIndicatorForRangeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15679{
15680 auto& vm = JSC::getVM(lexicalGlobalObject);
15681 auto throwScope = DECLARE_THROW_SCOPE(vm);
15682 UNUSED_PARAM(throwScope);
15683 UNUSED_PARAM(callFrame);
15684 auto& impl = castedThis->wrapped();
15685 if (UNLIKELY(callFrame->argumentCount() < 2))
15686 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15687 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15688 auto range = convert<IDLInterface<Range>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "range", "Internals", "textIndicatorForRange", "Range"); });
15689 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15690 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
15691 auto options = convert<IDLDictionary<Internals::TextIndicatorOptions>>(*lexicalGlobalObject, argument1.value());
15692 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15693 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDictionary<Internals::TextIndicatorInfo>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.textIndicatorForRange(*range, WTFMove(options)))));
15694}
15695
15696JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_textIndicatorForRange, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15697{
15698 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_textIndicatorForRangeBody>(*lexicalGlobalObject, *callFrame, "textIndicatorForRange");
15699}
15700
15701static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_addPrefetchLoadEventListenerBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15702{
15703 auto& vm = JSC::getVM(lexicalGlobalObject);
15704 auto throwScope = DECLARE_THROW_SCOPE(vm);
15705 UNUSED_PARAM(throwScope);
15706 UNUSED_PARAM(callFrame);
15707 auto& impl = castedThis->wrapped();
15708 if (UNLIKELY(callFrame->argumentCount() < 2))
15709 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15710 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15711 auto link = convert<IDLInterface<HTMLLinkElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "link", "Internals", "addPrefetchLoadEventListener", "HTMLLinkElement"); });
15712 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15713 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
15714 auto callback = convert<IDLNullable<IDLEventListener<JSEventListener>>>(*lexicalGlobalObject, argument1.value(), *castedThis);
15715 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15716 auto result = JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.addPrefetchLoadEventListener(*link, WTFMove(callback)); }));
15717 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15718 vm.heap.writeBarrier(&static_cast<JSObject&>(*castedThis), argument1.value());
15719 return result;
15720}
15721
15722JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_addPrefetchLoadEventListener, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15723{
15724 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_addPrefetchLoadEventListenerBody>(*lexicalGlobalObject, *callFrame, "addPrefetchLoadEventListener");
15725}
15726
15727#if ENABLE(WEB_AUTHN)
15728static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMockWebAuthenticationConfigurationBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15729{
15730 auto& vm = JSC::getVM(lexicalGlobalObject);
15731 auto throwScope = DECLARE_THROW_SCOPE(vm);
15732 UNUSED_PARAM(throwScope);
15733 UNUSED_PARAM(callFrame);
15734 auto& impl = castedThis->wrapped();
15735 if (UNLIKELY(callFrame->argumentCount() < 1))
15736 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15737 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15738 auto configuration = convert<IDLDictionary<MockWebAuthenticationConfiguration>>(*lexicalGlobalObject, argument0.value());
15739 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15740 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMockWebAuthenticationConfiguration(WTFMove(configuration)); })));
15741}
15742
15743JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMockWebAuthenticationConfiguration, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15744{
15745 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMockWebAuthenticationConfigurationBody>(*lexicalGlobalObject, *callFrame, "setMockWebAuthenticationConfiguration");
15746}
15747
15748#endif
15749
15750static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_createInternalsMapLikeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15751{
15752 auto& vm = JSC::getVM(lexicalGlobalObject);
15753 auto throwScope = DECLARE_THROW_SCOPE(vm);
15754 UNUSED_PARAM(throwScope);
15755 UNUSED_PARAM(callFrame);
15756 auto& impl = castedThis->wrapped();
15757 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<InternalsMapLike>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.createInternalsMapLike())));
15758}
15759
15760JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_createInternalsMapLike, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15761{
15762 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_createInternalsMapLikeBody>(*lexicalGlobalObject, *callFrame, "createInternalsMapLike");
15763}
15764
15765static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_createInternalsSetLikeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15766{
15767 auto& vm = JSC::getVM(lexicalGlobalObject);
15768 auto throwScope = DECLARE_THROW_SCOPE(vm);
15769 UNUSED_PARAM(throwScope);
15770 UNUSED_PARAM(callFrame);
15771 auto& impl = castedThis->wrapped();
15772 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<InternalsSetLike>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.createInternalsSetLike())));
15773}
15774
15775JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_createInternalsSetLike, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15776{
15777 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_createInternalsSetLikeBody>(*lexicalGlobalObject, *callFrame, "createInternalsSetLike");
15778}
15779
15780static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_highlightPseudoElementColorBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15781{
15782 auto& vm = JSC::getVM(lexicalGlobalObject);
15783 auto throwScope = DECLARE_THROW_SCOPE(vm);
15784 UNUSED_PARAM(throwScope);
15785 UNUSED_PARAM(callFrame);
15786 auto& impl = castedThis->wrapped();
15787 if (UNLIKELY(callFrame->argumentCount() < 2))
15788 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15789 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15790 auto highlightName = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
15791 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15792 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
15793 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "element", "Internals", "highlightPseudoElementColor", "Element"); });
15794 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15795 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.highlightPseudoElementColor(WTFMove(highlightName), *element))));
15796}
15797
15798JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_highlightPseudoElementColor, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15799{
15800 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_highlightPseudoElementColorBody>(*lexicalGlobalObject, *callFrame, "highlightPseudoElementColor");
15801}
15802
15803static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_hasSandboxMachLookupAccessToGlobalNameBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15804{
15805 auto& vm = JSC::getVM(lexicalGlobalObject);
15806 auto throwScope = DECLARE_THROW_SCOPE(vm);
15807 UNUSED_PARAM(throwScope);
15808 UNUSED_PARAM(callFrame);
15809 auto& impl = castedThis->wrapped();
15810 if (UNLIKELY(callFrame->argumentCount() < 2))
15811 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15812 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15813 auto process = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
15814 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15815 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
15816 auto service = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
15817 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15818 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.hasSandboxMachLookupAccessToGlobalName(WTFMove(process), WTFMove(service)))));
15819}
15820
15821JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasSandboxMachLookupAccessToGlobalName, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15822{
15823 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_hasSandboxMachLookupAccessToGlobalNameBody>(*lexicalGlobalObject, *callFrame, "hasSandboxMachLookupAccessToGlobalName");
15824}
15825
15826static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_hasSandboxMachLookupAccessToXPCServiceNameBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15827{
15828 auto& vm = JSC::getVM(lexicalGlobalObject);
15829 auto throwScope = DECLARE_THROW_SCOPE(vm);
15830 UNUSED_PARAM(throwScope);
15831 UNUSED_PARAM(callFrame);
15832 auto& impl = castedThis->wrapped();
15833 if (UNLIKELY(callFrame->argumentCount() < 2))
15834 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15835 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15836 auto process = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
15837 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15838 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
15839 auto service = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
15840 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15841 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.hasSandboxMachLookupAccessToXPCServiceName(WTFMove(process), WTFMove(service)))));
15842}
15843
15844JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasSandboxMachLookupAccessToXPCServiceName, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15845{
15846 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_hasSandboxMachLookupAccessToXPCServiceNameBody>(*lexicalGlobalObject, *callFrame, "hasSandboxMachLookupAccessToXPCServiceName");
15847}
15848
15849static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_hasSandboxIOKitOpenAccessToClassBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15850{
15851 auto& vm = JSC::getVM(lexicalGlobalObject);
15852 auto throwScope = DECLARE_THROW_SCOPE(vm);
15853 UNUSED_PARAM(throwScope);
15854 UNUSED_PARAM(callFrame);
15855 auto& impl = castedThis->wrapped();
15856 if (UNLIKELY(callFrame->argumentCount() < 2))
15857 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15858 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15859 auto process = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
15860 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15861 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
15862 auto ioKitClass = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
15863 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15864 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.hasSandboxIOKitOpenAccessToClass(WTFMove(process), WTFMove(ioKitClass)))));
15865}
15866
15867JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_hasSandboxIOKitOpenAccessToClass, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15868{
15869 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_hasSandboxIOKitOpenAccessToClassBody>(*lexicalGlobalObject, *callFrame, "hasSandboxIOKitOpenAccessToClass");
15870}
15871
15872static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_systemColorForCSSValueBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15873{
15874 auto& vm = JSC::getVM(lexicalGlobalObject);
15875 auto throwScope = DECLARE_THROW_SCOPE(vm);
15876 UNUSED_PARAM(throwScope);
15877 UNUSED_PARAM(callFrame);
15878 auto& impl = castedThis->wrapped();
15879 if (UNLIKELY(callFrame->argumentCount() < 3))
15880 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15881 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15882 auto cssValue = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
15883 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15884 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
15885 auto useDarkModeAppearance = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
15886 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15887 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
15888 auto useElevatedUserInterfaceLevel = convert<IDLBoolean>(*lexicalGlobalObject, argument2.value());
15889 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15890 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.systemColorForCSSValue(WTFMove(cssValue), WTFMove(useDarkModeAppearance), WTFMove(useElevatedUserInterfaceLevel)))));
15891}
15892
15893JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_systemColorForCSSValue, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15894{
15895 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_systemColorForCSSValueBody>(*lexicalGlobalObject, *callFrame, "systemColorForCSSValue");
15896}
15897
15898static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_focusRingColorBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15899{
15900 auto& vm = JSC::getVM(lexicalGlobalObject);
15901 auto throwScope = DECLARE_THROW_SCOPE(vm);
15902 UNUSED_PARAM(throwScope);
15903 UNUSED_PARAM(callFrame);
15904 auto& impl = castedThis->wrapped();
15905 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.focusRingColor())));
15906}
15907
15908JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_focusRingColor, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15909{
15910 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_focusRingColorBody>(*lexicalGlobalObject, *callFrame, "focusRingColor");
15911}
15912
15913static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_systemHasBatteryBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15914{
15915 auto& vm = JSC::getVM(lexicalGlobalObject);
15916 auto throwScope = DECLARE_THROW_SCOPE(vm);
15917 UNUSED_PARAM(throwScope);
15918 UNUSED_PARAM(callFrame);
15919 auto& impl = castedThis->wrapped();
15920 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.systemHasBattery())));
15921}
15922
15923JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_systemHasBattery, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15924{
15925 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_systemHasBatteryBody>(*lexicalGlobalObject, *callFrame, "systemHasBattery");
15926}
15927
15928static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setSystemHasBatteryForTestingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15929{
15930 auto& vm = JSC::getVM(lexicalGlobalObject);
15931 auto throwScope = DECLARE_THROW_SCOPE(vm);
15932 UNUSED_PARAM(throwScope);
15933 UNUSED_PARAM(callFrame);
15934 auto& impl = castedThis->wrapped();
15935 if (UNLIKELY(callFrame->argumentCount() < 1))
15936 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15937 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15938 auto hasBattery = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
15939 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15940 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setSystemHasBatteryForTesting(WTFMove(hasBattery)); })));
15941}
15942
15943JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setSystemHasBatteryForTesting, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15944{
15945 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setSystemHasBatteryForTestingBody>(*lexicalGlobalObject, *callFrame, "setSystemHasBatteryForTesting");
15946}
15947
15948static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setSystemHasACForTestingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15949{
15950 auto& vm = JSC::getVM(lexicalGlobalObject);
15951 auto throwScope = DECLARE_THROW_SCOPE(vm);
15952 UNUSED_PARAM(throwScope);
15953 UNUSED_PARAM(callFrame);
15954 auto& impl = castedThis->wrapped();
15955 if (UNLIKELY(callFrame->argumentCount() < 1))
15956 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15957 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15958 auto hasAC = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
15959 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15960 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setSystemHasACForTesting(WTFMove(hasAC)); })));
15961}
15962
15963JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setSystemHasACForTesting, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15964{
15965 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setSystemHasACForTestingBody>(*lexicalGlobalObject, *callFrame, "setSystemHasACForTesting");
15966}
15967
15968static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setHardwareVP9DecoderDisabledForTestingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15969{
15970 auto& vm = JSC::getVM(lexicalGlobalObject);
15971 auto throwScope = DECLARE_THROW_SCOPE(vm);
15972 UNUSED_PARAM(throwScope);
15973 UNUSED_PARAM(callFrame);
15974 auto& impl = castedThis->wrapped();
15975 if (UNLIKELY(callFrame->argumentCount() < 1))
15976 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15977 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15978 auto disabled = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
15979 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
15980 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setHardwareVP9DecoderDisabledForTesting(WTFMove(disabled)); })));
15981}
15982
15983JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setHardwareVP9DecoderDisabledForTesting, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
15984{
15985 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setHardwareVP9DecoderDisabledForTestingBody>(*lexicalGlobalObject, *callFrame, "setHardwareVP9DecoderDisabledForTesting");
15986}
15987
15988static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setVP9ScreenSizeAndScaleForTestingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
15989{
15990 auto& vm = JSC::getVM(lexicalGlobalObject);
15991 auto throwScope = DECLARE_THROW_SCOPE(vm);
15992 UNUSED_PARAM(throwScope);
15993 UNUSED_PARAM(callFrame);
15994 auto& impl = castedThis->wrapped();
15995 if (UNLIKELY(callFrame->argumentCount() < 3))
15996 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
15997 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
15998 auto width = convert<IDLDouble>(*lexicalGlobalObject, argument0.value());
15999 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16000 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
16001 auto height = convert<IDLDouble>(*lexicalGlobalObject, argument1.value());
16002 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16003 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
16004 auto scale = convert<IDLDouble>(*lexicalGlobalObject, argument2.value());
16005 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16006 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setVP9ScreenSizeAndScaleForTesting(WTFMove(width), WTFMove(height), WTFMove(scale)); })));
16007}
16008
16009JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setVP9ScreenSizeAndScaleForTesting, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16010{
16011 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setVP9ScreenSizeAndScaleForTestingBody>(*lexicalGlobalObject, *callFrame, "setVP9ScreenSizeAndScaleForTesting");
16012}
16013
16014static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_readPreferenceIntegerBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16015{
16016 auto& vm = JSC::getVM(lexicalGlobalObject);
16017 auto throwScope = DECLARE_THROW_SCOPE(vm);
16018 UNUSED_PARAM(throwScope);
16019 UNUSED_PARAM(callFrame);
16020 auto& impl = castedThis->wrapped();
16021 if (UNLIKELY(callFrame->argumentCount() < 2))
16022 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16023 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16024 auto domain = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
16025 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16026 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
16027 auto key = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
16028 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16029 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLLong>(*lexicalGlobalObject, throwScope, impl.readPreferenceInteger(WTFMove(domain), WTFMove(key)))));
16030}
16031
16032JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_readPreferenceInteger, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16033{
16034 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_readPreferenceIntegerBody>(*lexicalGlobalObject, *callFrame, "readPreferenceInteger");
16035}
16036
16037static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_encodedPreferenceValueBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16038{
16039 auto& vm = JSC::getVM(lexicalGlobalObject);
16040 auto throwScope = DECLARE_THROW_SCOPE(vm);
16041 UNUSED_PARAM(throwScope);
16042 UNUSED_PARAM(callFrame);
16043 auto& impl = castedThis->wrapped();
16044 if (UNLIKELY(callFrame->argumentCount() < 2))
16045 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16046 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16047 auto domain = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
16048 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16049 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
16050 auto key = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
16051 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16052 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.encodedPreferenceValue(WTFMove(domain), WTFMove(key)))));
16053}
16054
16055JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_encodedPreferenceValue, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16056{
16057 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_encodedPreferenceValueBody>(*lexicalGlobalObject, *callFrame, "encodedPreferenceValue");
16058}
16059
16060static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_getUTIFromTagBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16061{
16062 auto& vm = JSC::getVM(lexicalGlobalObject);
16063 auto throwScope = DECLARE_THROW_SCOPE(vm);
16064 UNUSED_PARAM(throwScope);
16065 UNUSED_PARAM(callFrame);
16066 auto& impl = castedThis->wrapped();
16067 if (UNLIKELY(callFrame->argumentCount() < 3))
16068 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16069 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16070 auto tagClass = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
16071 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16072 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
16073 auto tag = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
16074 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16075 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
16076 auto conformingToUTI = convert<IDLDOMString>(*lexicalGlobalObject, argument2.value());
16077 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16078 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.getUTIFromTag(WTFMove(tagClass), WTFMove(tag), WTFMove(conformingToUTI)))));
16079}
16080
16081JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_getUTIFromTag, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16082{
16083 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_getUTIFromTagBody>(*lexicalGlobalObject, *callFrame, "getUTIFromTag");
16084}
16085
16086static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_supportsPictureInPictureBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16087{
16088 auto& vm = JSC::getVM(lexicalGlobalObject);
16089 auto throwScope = DECLARE_THROW_SCOPE(vm);
16090 UNUSED_PARAM(throwScope);
16091 UNUSED_PARAM(callFrame);
16092 auto& impl = castedThis->wrapped();
16093 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.supportsPictureInPicture())));
16094}
16095
16096JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_supportsPictureInPicture, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16097{
16098 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_supportsPictureInPictureBody>(*lexicalGlobalObject, *callFrame, "supportsPictureInPicture");
16099}
16100
16101static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_isRemoteUIAppForAccessibilityBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16102{
16103 auto& vm = JSC::getVM(lexicalGlobalObject);
16104 auto throwScope = DECLARE_THROW_SCOPE(vm);
16105 UNUSED_PARAM(throwScope);
16106 UNUSED_PARAM(callFrame);
16107 auto& impl = castedThis->wrapped();
16108 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isRemoteUIAppForAccessibility())));
16109}
16110
16111JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_isRemoteUIAppForAccessibility, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16112{
16113 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_isRemoteUIAppForAccessibilityBody>(*lexicalGlobalObject, *callFrame, "isRemoteUIAppForAccessibility");
16114}
16115
16116static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_createSleepDisablerBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16117{
16118 auto& vm = JSC::getVM(lexicalGlobalObject);
16119 auto throwScope = DECLARE_THROW_SCOPE(vm);
16120 UNUSED_PARAM(throwScope);
16121 UNUSED_PARAM(callFrame);
16122 auto& impl = castedThis->wrapped();
16123 if (UNLIKELY(callFrame->argumentCount() < 2))
16124 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16125 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16126 auto reason = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
16127 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16128 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
16129 auto display = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
16130 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16131 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.createSleepDisabler(WTFMove(reason), WTFMove(display)))));
16132}
16133
16134JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_createSleepDisabler, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16135{
16136 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_createSleepDisablerBody>(*lexicalGlobalObject, *callFrame, "createSleepDisabler");
16137}
16138
16139static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_destroySleepDisablerBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16140{
16141 auto& vm = JSC::getVM(lexicalGlobalObject);
16142 auto throwScope = DECLARE_THROW_SCOPE(vm);
16143 UNUSED_PARAM(throwScope);
16144 UNUSED_PARAM(callFrame);
16145 auto& impl = castedThis->wrapped();
16146 if (UNLIKELY(callFrame->argumentCount() < 1))
16147 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16148 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16149 auto identifier = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument0.value());
16150 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16151 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.destroySleepDisabler(WTFMove(identifier)))));
16152}
16153
16154JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_destroySleepDisabler, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16155{
16156 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_destroySleepDisablerBody>(*lexicalGlobalObject, *callFrame, "destroySleepDisabler");
16157}
16158
16159#if ENABLE(APP_HIGHLIGHTS)
16160static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_numberOfAppHighlightsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16161{
16162 auto& vm = JSC::getVM(lexicalGlobalObject);
16163 auto throwScope = DECLARE_THROW_SCOPE(vm);
16164 UNUSED_PARAM(throwScope);
16165 UNUSED_PARAM(callFrame);
16166 auto& impl = castedThis->wrapped();
16167 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.numberOfAppHighlights())));
16168}
16169
16170JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_numberOfAppHighlights, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16171{
16172 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_numberOfAppHighlightsBody>(*lexicalGlobalObject, *callFrame, "numberOfAppHighlights");
16173}
16174
16175#endif
16176
16177#if ENABLE(ENCRYPTED_MEDIA)
16178static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_mediaKeysInternalInstanceObjectRefCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16179{
16180 auto& vm = JSC::getVM(lexicalGlobalObject);
16181 auto throwScope = DECLARE_THROW_SCOPE(vm);
16182 UNUSED_PARAM(throwScope);
16183 UNUSED_PARAM(callFrame);
16184 auto& impl = castedThis->wrapped();
16185 if (UNLIKELY(callFrame->argumentCount() < 1))
16186 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16187 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16188 auto mediaKeys = convert<IDLInterface<MediaKeys>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "mediaKeys", "Internals", "mediaKeysInternalInstanceObjectRefCount", "MediaKeys"); });
16189 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16190 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.mediaKeysInternalInstanceObjectRefCount(*mediaKeys))));
16191}
16192
16193JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaKeysInternalInstanceObjectRefCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16194{
16195 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_mediaKeysInternalInstanceObjectRefCountBody>(*lexicalGlobalObject, *callFrame, "mediaKeysInternalInstanceObjectRefCount");
16196}
16197
16198#endif
16199
16200#if ENABLE(ENCRYPTED_MEDIA)
16201static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_mediaKeySessionInternalInstanceSessionObjectRefCountBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16202{
16203 auto& vm = JSC::getVM(lexicalGlobalObject);
16204 auto throwScope = DECLARE_THROW_SCOPE(vm);
16205 UNUSED_PARAM(throwScope);
16206 UNUSED_PARAM(callFrame);
16207 auto& impl = castedThis->wrapped();
16208 if (UNLIKELY(callFrame->argumentCount() < 1))
16209 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16210 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16211 auto session = convert<IDLInterface<MediaKeySession>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "session", "Internals", "mediaKeySessionInternalInstanceSessionObjectRefCount", "MediaKeySession"); });
16212 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16213 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.mediaKeySessionInternalInstanceSessionObjectRefCount(*session))));
16214}
16215
16216JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_mediaKeySessionInternalInstanceSessionObjectRefCount, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16217{
16218 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_mediaKeySessionInternalInstanceSessionObjectRefCountBody>(*lexicalGlobalObject, *callFrame, "mediaKeySessionInternalInstanceSessionObjectRefCount");
16219}
16220
16221#endif
16222
16223static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setContentSizeCategoryBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16224{
16225 auto& vm = JSC::getVM(lexicalGlobalObject);
16226 auto throwScope = DECLARE_THROW_SCOPE(vm);
16227 UNUSED_PARAM(throwScope);
16228 UNUSED_PARAM(callFrame);
16229 auto& impl = castedThis->wrapped();
16230 if (UNLIKELY(callFrame->argumentCount() < 1))
16231 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16232 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16233 auto category = convert<IDLEnumeration<Internals::ContentSizeCategory>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 0, "category", "Internals", "setContentSizeCategory", expectedEnumerationValues<Internals::ContentSizeCategory>()); });
16234 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16235 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setContentSizeCategory(WTFMove(category)); })));
16236}
16237
16238JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setContentSizeCategory, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16239{
16240 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setContentSizeCategoryBody>(*lexicalGlobalObject, *callFrame, "setContentSizeCategory");
16241}
16242
16243#if ENABLE(ATTACHMENT_ELEMENT)
16244static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_attachmentThumbnailInfoBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16245{
16246 auto& vm = JSC::getVM(lexicalGlobalObject);
16247 auto throwScope = DECLARE_THROW_SCOPE(vm);
16248 UNUSED_PARAM(throwScope);
16249 UNUSED_PARAM(callFrame);
16250 auto& impl = castedThis->wrapped();
16251 if (UNLIKELY(callFrame->argumentCount() < 1))
16252 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16253 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16254 auto element = convert<IDLInterface<HTMLAttachmentElement>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Internals", "attachmentThumbnailInfo", "HTMLAttachmentElement"); });
16255 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16256 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDictionary<Internals::AttachmentThumbnailInfo>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.attachmentThumbnailInfo(*element))));
16257}
16258
16259JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_attachmentThumbnailInfo, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16260{
16261 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_attachmentThumbnailInfoBody>(*lexicalGlobalObject, *callFrame, "attachmentThumbnailInfo");
16262}
16263
16264#endif
16265
16266#if ENABLE(MEDIA_SESSION)
16267static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_currentMediaSessionPositionBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16268{
16269 auto& vm = JSC::getVM(lexicalGlobalObject);
16270 auto throwScope = DECLARE_THROW_SCOPE(vm);
16271 UNUSED_PARAM(throwScope);
16272 UNUSED_PARAM(callFrame);
16273 auto& impl = castedThis->wrapped();
16274 if (UNLIKELY(callFrame->argumentCount() < 1))
16275 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16276 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16277 auto session = convert<IDLInterface<MediaSession>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "session", "Internals", "currentMediaSessionPosition", "MediaSession"); });
16278 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16279 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.currentMediaSessionPosition(*session))));
16280}
16281
16282JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_currentMediaSessionPosition, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16283{
16284 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_currentMediaSessionPositionBody>(*lexicalGlobalObject, *callFrame, "currentMediaSessionPosition");
16285}
16286
16287#endif
16288
16289#if ENABLE(MEDIA_SESSION)
16290static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_sendMediaSessionActionBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16291{
16292 auto& vm = JSC::getVM(lexicalGlobalObject);
16293 auto throwScope = DECLARE_THROW_SCOPE(vm);
16294 UNUSED_PARAM(throwScope);
16295 UNUSED_PARAM(callFrame);
16296 auto& impl = castedThis->wrapped();
16297 if (UNLIKELY(callFrame->argumentCount() < 2))
16298 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16299 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16300 auto session = convert<IDLInterface<MediaSession>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "session", "Internals", "sendMediaSessionAction", "MediaSession"); });
16301 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16302 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
16303 auto actionDetails = convert<IDLDictionary<MediaSessionActionDetails>>(*lexicalGlobalObject, argument1.value());
16304 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16305 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.sendMediaSessionAction(*session, WTFMove(actionDetails)); })));
16306}
16307
16308JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_sendMediaSessionAction, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16309{
16310 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_sendMediaSessionActionBody>(*lexicalGlobalObject, *callFrame, "sendMediaSessionAction");
16311}
16312
16313#endif
16314
16315#if ENABLE(MEDIA_SESSION)
16316static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_loadArtworkImageBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
16317{
16318 auto& vm = JSC::getVM(lexicalGlobalObject);
16319 auto throwScope = DECLARE_THROW_SCOPE(vm);
16320 UNUSED_PARAM(throwScope);
16321 UNUSED_PARAM(callFrame);
16322 auto& impl = castedThis->wrapped();
16323 if (UNLIKELY(callFrame->argumentCount() < 1))
16324 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16325 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16326 auto url = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
16327 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16328 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLInterface<ImageData>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.loadArtworkImage(WTFMove(url), WTFMove(promise)); })));
16329}
16330
16331JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_loadArtworkImage, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16332{
16333 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunction_loadArtworkImageBody>(*lexicalGlobalObject, *callFrame, "loadArtworkImage");
16334}
16335
16336#endif
16337
16338#if ENABLE(MEDIA_SESSION_COORDINATOR)
16339static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_registerMockMediaSessionCoordinatorBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16340{
16341 auto& vm = JSC::getVM(lexicalGlobalObject);
16342 auto throwScope = DECLARE_THROW_SCOPE(vm);
16343 UNUSED_PARAM(throwScope);
16344 UNUSED_PARAM(callFrame);
16345 auto& impl = castedThis->wrapped();
16346 if (UNLIKELY(callFrame->argumentCount() < 1))
16347 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16348 auto* context = jsCast<JSDOMGlobalObject*>(lexicalGlobalObject)->scriptExecutionContext();
16349 if (UNLIKELY(!context))
16350 return JSValue::encode(jsUndefined());
16351 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16352 auto callback = convert<IDLCallbackFunction<JSStringCallback>>(*lexicalGlobalObject, argument0.value(), *castedThis->globalObject(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(lexicalGlobalObject, scope, 0, "callback", "Internals", "registerMockMediaSessionCoordinator"); });
16353 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16354 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.registerMockMediaSessionCoordinator(*context, callback.releaseNonNull()); })));
16355}
16356
16357JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_registerMockMediaSessionCoordinator, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16358{
16359 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_registerMockMediaSessionCoordinatorBody>(*lexicalGlobalObject, *callFrame, "registerMockMediaSessionCoordinator");
16360}
16361
16362#endif
16363
16364#if ENABLE(MEDIA_SESSION_COORDINATOR)
16365static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setMockMediaSessionCoordinatorCommandsShouldFailBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16366{
16367 auto& vm = JSC::getVM(lexicalGlobalObject);
16368 auto throwScope = DECLARE_THROW_SCOPE(vm);
16369 UNUSED_PARAM(throwScope);
16370 UNUSED_PARAM(callFrame);
16371 auto& impl = castedThis->wrapped();
16372 if (UNLIKELY(callFrame->argumentCount() < 1))
16373 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16374 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16375 auto shouldFail = convert<IDLBoolean>(*lexicalGlobalObject, argument0.value());
16376 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16377 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setMockMediaSessionCoordinatorCommandsShouldFail(WTFMove(shouldFail)); })));
16378}
16379
16380JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setMockMediaSessionCoordinatorCommandsShouldFail, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16381{
16382 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setMockMediaSessionCoordinatorCommandsShouldFailBody>(*lexicalGlobalObject, *callFrame, "setMockMediaSessionCoordinatorCommandsShouldFail");
16383}
16384
16385#endif
16386
16387static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_treeOrderBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16388{
16389 auto& vm = JSC::getVM(lexicalGlobalObject);
16390 auto throwScope = DECLARE_THROW_SCOPE(vm);
16391 UNUSED_PARAM(throwScope);
16392 UNUSED_PARAM(callFrame);
16393 auto& impl = castedThis->wrapped();
16394 if (UNLIKELY(callFrame->argumentCount() < 2))
16395 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16396 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16397 auto a = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "a", "Internals", "treeOrder", "Node"); });
16398 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16399 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
16400 auto b = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "b", "Internals", "treeOrder", "Node"); });
16401 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16402 EnsureStillAliveScope argument2 = callFrame->argument(2);
16403 auto tree = argument2.value().isUndefined() ? Internals::TreeType::Tree : convert<IDLEnumeration<Internals::TreeType>>(*lexicalGlobalObject, argument2.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 2, "tree", "Internals", "treeOrder", expectedEnumerationValues<Internals::TreeType>()); });
16404 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16405 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.treeOrder(*a, *b, WTFMove(tree)))));
16406}
16407
16408JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_treeOrder, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16409{
16410 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_treeOrderBody>(*lexicalGlobalObject, *callFrame, "treeOrder");
16411}
16412
16413static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_treeOrderBoundaryPointsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16414{
16415 auto& vm = JSC::getVM(lexicalGlobalObject);
16416 auto throwScope = DECLARE_THROW_SCOPE(vm);
16417 UNUSED_PARAM(throwScope);
16418 UNUSED_PARAM(callFrame);
16419 auto& impl = castedThis->wrapped();
16420 if (UNLIKELY(callFrame->argumentCount() < 4))
16421 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16422 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16423 auto containerA = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "containerA", "Internals", "treeOrderBoundaryPoints", "Node"); });
16424 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16425 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
16426 auto offsetA = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument1.value());
16427 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16428 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
16429 auto containerB = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument2.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 2, "containerB", "Internals", "treeOrderBoundaryPoints", "Node"); });
16430 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16431 EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
16432 auto offsetB = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument3.value());
16433 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16434 EnsureStillAliveScope argument4 = callFrame->argument(4);
16435 auto tree = argument4.value().isUndefined() ? Internals::TreeType::Tree : convert<IDLEnumeration<Internals::TreeType>>(*lexicalGlobalObject, argument4.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 4, "tree", "Internals", "treeOrderBoundaryPoints", expectedEnumerationValues<Internals::TreeType>()); });
16436 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16437 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.treeOrderBoundaryPoints(*containerA, WTFMove(offsetA), *containerB, WTFMove(offsetB), WTFMove(tree)))));
16438}
16439
16440JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_treeOrderBoundaryPoints, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16441{
16442 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_treeOrderBoundaryPointsBody>(*lexicalGlobalObject, *callFrame, "treeOrderBoundaryPoints");
16443}
16444
16445static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_rangeContainsNodeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16446{
16447 auto& vm = JSC::getVM(lexicalGlobalObject);
16448 auto throwScope = DECLARE_THROW_SCOPE(vm);
16449 UNUSED_PARAM(throwScope);
16450 UNUSED_PARAM(callFrame);
16451 auto& impl = castedThis->wrapped();
16452 if (UNLIKELY(callFrame->argumentCount() < 2))
16453 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16454 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16455 auto range = convert<IDLInterface<AbstractRange>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "range", "Internals", "rangeContainsNode", "AbstractRange"); });
16456 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16457 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
16458 auto node = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "node", "Internals", "rangeContainsNode", "Node"); });
16459 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16460 EnsureStillAliveScope argument2 = callFrame->argument(2);
16461 auto tree = argument2.value().isUndefined() ? Internals::TreeType::Tree : convert<IDLEnumeration<Internals::TreeType>>(*lexicalGlobalObject, argument2.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 2, "tree", "Internals", "rangeContainsNode", expectedEnumerationValues<Internals::TreeType>()); });
16462 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16463 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.rangeContainsNode(*range, *node, WTFMove(tree)))));
16464}
16465
16466JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeContainsNode, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16467{
16468 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_rangeContainsNodeBody>(*lexicalGlobalObject, *callFrame, "rangeContainsNode");
16469}
16470
16471static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_rangeContainsRangeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16472{
16473 auto& vm = JSC::getVM(lexicalGlobalObject);
16474 auto throwScope = DECLARE_THROW_SCOPE(vm);
16475 UNUSED_PARAM(throwScope);
16476 UNUSED_PARAM(callFrame);
16477 auto& impl = castedThis->wrapped();
16478 if (UNLIKELY(callFrame->argumentCount() < 2))
16479 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16480 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16481 auto outerRange = convert<IDLInterface<AbstractRange>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "outerRange", "Internals", "rangeContainsRange", "AbstractRange"); });
16482 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16483 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
16484 auto innerRange = convert<IDLInterface<AbstractRange>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "innerRange", "Internals", "rangeContainsRange", "AbstractRange"); });
16485 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16486 EnsureStillAliveScope argument2 = callFrame->argument(2);
16487 auto tree = argument2.value().isUndefined() ? Internals::TreeType::Tree : convert<IDLEnumeration<Internals::TreeType>>(*lexicalGlobalObject, argument2.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 2, "tree", "Internals", "rangeContainsRange", expectedEnumerationValues<Internals::TreeType>()); });
16488 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16489 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.rangeContainsRange(*outerRange, *innerRange, WTFMove(tree)))));
16490}
16491
16492JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeContainsRange, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16493{
16494 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_rangeContainsRangeBody>(*lexicalGlobalObject, *callFrame, "rangeContainsRange");
16495}
16496
16497static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_rangeContainsBoundaryPointBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16498{
16499 auto& vm = JSC::getVM(lexicalGlobalObject);
16500 auto throwScope = DECLARE_THROW_SCOPE(vm);
16501 UNUSED_PARAM(throwScope);
16502 UNUSED_PARAM(callFrame);
16503 auto& impl = castedThis->wrapped();
16504 if (UNLIKELY(callFrame->argumentCount() < 3))
16505 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16506 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16507 auto outerRange = convert<IDLInterface<AbstractRange>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "outerRange", "Internals", "rangeContainsBoundaryPoint", "AbstractRange"); });
16508 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16509 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
16510 auto container = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "container", "Internals", "rangeContainsBoundaryPoint", "Node"); });
16511 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16512 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
16513 auto offset = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument2.value());
16514 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16515 EnsureStillAliveScope argument3 = callFrame->argument(3);
16516 auto tree = argument3.value().isUndefined() ? Internals::TreeType::Tree : convert<IDLEnumeration<Internals::TreeType>>(*lexicalGlobalObject, argument3.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 3, "tree", "Internals", "rangeContainsBoundaryPoint", expectedEnumerationValues<Internals::TreeType>()); });
16517 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16518 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.rangeContainsBoundaryPoint(*outerRange, *container, WTFMove(offset), WTFMove(tree)))));
16519}
16520
16521JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeContainsBoundaryPoint, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16522{
16523 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_rangeContainsBoundaryPointBody>(*lexicalGlobalObject, *callFrame, "rangeContainsBoundaryPoint");
16524}
16525
16526static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_rangeIntersectsNodeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16527{
16528 auto& vm = JSC::getVM(lexicalGlobalObject);
16529 auto throwScope = DECLARE_THROW_SCOPE(vm);
16530 UNUSED_PARAM(throwScope);
16531 UNUSED_PARAM(callFrame);
16532 auto& impl = castedThis->wrapped();
16533 if (UNLIKELY(callFrame->argumentCount() < 2))
16534 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16535 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16536 auto range = convert<IDLInterface<AbstractRange>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "range", "Internals", "rangeIntersectsNode", "AbstractRange"); });
16537 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16538 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
16539 auto node = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "node", "Internals", "rangeIntersectsNode", "Node"); });
16540 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16541 EnsureStillAliveScope argument2 = callFrame->argument(2);
16542 auto tree = argument2.value().isUndefined() ? Internals::TreeType::Tree : convert<IDLEnumeration<Internals::TreeType>>(*lexicalGlobalObject, argument2.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 2, "tree", "Internals", "rangeIntersectsNode", expectedEnumerationValues<Internals::TreeType>()); });
16543 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16544 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.rangeIntersectsNode(*range, *node, WTFMove(tree)))));
16545}
16546
16547JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeIntersectsNode, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16548{
16549 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_rangeIntersectsNodeBody>(*lexicalGlobalObject, *callFrame, "rangeIntersectsNode");
16550}
16551
16552static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_rangeIntersectsRangeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16553{
16554 auto& vm = JSC::getVM(lexicalGlobalObject);
16555 auto throwScope = DECLARE_THROW_SCOPE(vm);
16556 UNUSED_PARAM(throwScope);
16557 UNUSED_PARAM(callFrame);
16558 auto& impl = castedThis->wrapped();
16559 if (UNLIKELY(callFrame->argumentCount() < 2))
16560 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16561 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16562 auto outerRange = convert<IDLInterface<AbstractRange>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "outerRange", "Internals", "rangeIntersectsRange", "AbstractRange"); });
16563 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16564 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
16565 auto innerRange = convert<IDLInterface<AbstractRange>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "innerRange", "Internals", "rangeIntersectsRange", "AbstractRange"); });
16566 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16567 EnsureStillAliveScope argument2 = callFrame->argument(2);
16568 auto tree = argument2.value().isUndefined() ? Internals::TreeType::Tree : convert<IDLEnumeration<Internals::TreeType>>(*lexicalGlobalObject, argument2.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 2, "tree", "Internals", "rangeIntersectsRange", expectedEnumerationValues<Internals::TreeType>()); });
16569 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16570 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.rangeIntersectsRange(*outerRange, *innerRange, WTFMove(tree)))));
16571}
16572
16573JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_rangeIntersectsRange, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16574{
16575 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_rangeIntersectsRangeBody>(*lexicalGlobalObject, *callFrame, "rangeIntersectsRange");
16576}
16577
16578static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_systemBeepBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16579{
16580 auto& vm = JSC::getVM(lexicalGlobalObject);
16581 auto throwScope = DECLARE_THROW_SCOPE(vm);
16582 UNUSED_PARAM(throwScope);
16583 UNUSED_PARAM(callFrame);
16584 auto& impl = castedThis->wrapped();
16585 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.systemBeep(); })));
16586}
16587
16588JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_systemBeep, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16589{
16590 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_systemBeepBody>(*lexicalGlobalObject, *callFrame, "systemBeep");
16591}
16592
16593static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_dumpStyleResolversBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16594{
16595 auto& vm = JSC::getVM(lexicalGlobalObject);
16596 auto throwScope = DECLARE_THROW_SCOPE(vm);
16597 UNUSED_PARAM(throwScope);
16598 UNUSED_PARAM(callFrame);
16599 auto& impl = castedThis->wrapped();
16600 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.dumpStyleResolvers())));
16601}
16602
16603JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_dumpStyleResolvers, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16604{
16605 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_dumpStyleResolversBody>(*lexicalGlobalObject, *callFrame, "dumpStyleResolvers");
16606}
16607
16608static inline JSC::EncodedJSValue jsInternalsPrototypeFunction_setDocumentAutoplayPolicyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSInternals>::ClassParameter castedThis)
16609{
16610 auto& vm = JSC::getVM(lexicalGlobalObject);
16611 auto throwScope = DECLARE_THROW_SCOPE(vm);
16612 UNUSED_PARAM(throwScope);
16613 UNUSED_PARAM(callFrame);
16614 auto& impl = castedThis->wrapped();
16615 if (UNLIKELY(callFrame->argumentCount() < 2))
16616 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
16617 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
16618 auto document = convert<IDLInterface<Document>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "document", "Internals", "setDocumentAutoplayPolicy", "Document"); });
16619 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16620 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
16621 auto policy = convert<IDLEnumeration<Internals::AutoplayPolicy>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 1, "policy", "Internals", "setDocumentAutoplayPolicy", expectedEnumerationValues<Internals::AutoplayPolicy>()); });
16622 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
16623 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setDocumentAutoplayPolicy(*document, WTFMove(policy)); })));
16624}
16625
16626JSC_DEFINE_HOST_FUNCTION(jsInternalsPrototypeFunction_setDocumentAutoplayPolicy, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
16627{
16628 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunction_setDocumentAutoplayPolicyBody>(*lexicalGlobalObject, *callFrame, "setDocumentAutoplayPolicy");
16629}
16630
16631JSC::IsoSubspace* JSInternals::subspaceForImpl(JSC::VM& vm)
16632{
16633 auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
16634 auto& spaces = clientData.subspaces();
16635 if (auto* space = spaces.m_subspaceForInternals.get())
16636 return space;
16637 static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSInternals> || !JSInternals::needsDestruction);
16638 if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSInternals>)
16639 spaces.m_subspaceForInternals = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSInternals);
16640 else
16641 spaces.m_subspaceForInternals = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSInternals);
16642 auto* space = spaces.m_subspaceForInternals.get();
16643IGNORE_WARNINGS_BEGIN("unreachable-code")
16644IGNORE_WARNINGS_BEGIN("tautological-compare")
16645 void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSInternals::visitOutputConstraints;
16646 void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
16647 if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
16648 clientData.outputConstraintSpaces().append(space);
16649IGNORE_WARNINGS_END
16650IGNORE_WARNINGS_END
16651 return space;
16652}
16653
16654void JSInternals::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
16655{
16656 auto* thisObject = jsCast<JSInternals*>(cell);
16657 analyzer.setWrappedObjectForCell(cell, &thisObject->wrapped());
16658 if (thisObject->scriptExecutionContext())
16659 analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
16660 Base::analyzeHeap(cell, analyzer);
16661}
16662
16663bool JSInternalsOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, AbstractSlotVisitor& visitor, const char** reason)
16664{
16665 UNUSED_PARAM(handle);
16666 UNUSED_PARAM(visitor);
16667 UNUSED_PARAM(reason);
16668 return false;
16669}
16670
16671void JSInternalsOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
16672{
16673 auto* jsInternals = static_cast<JSInternals*>(handle.slot()->asCell());
16674 auto& world = *static_cast<DOMWrapperWorld*>(context);
16675 uncacheWrapper(world, &jsInternals->wrapped(), jsInternals);
16676}
16677
16678#if ENABLE(BINDING_INTEGRITY)
16679#if PLATFORM(WIN)
16680#pragma warning(disable: 4483)
16681extern "C" { extern void (*const __identifier("??_7Internals@WebCore@@6B@")[])(); }
16682#else
16683extern "C" { extern void* _ZTVN7WebCore9InternalsE[]; }
16684#endif
16685#endif
16686
16687JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject*, JSDOMGlobalObject* globalObject, Ref<Internals>&& impl)
16688{
16689
16690#if ENABLE(BINDING_INTEGRITY)
16691 const void* actualVTablePointer = getVTablePointer(impl.ptr());
16692#if PLATFORM(WIN)
16693 void* expectedVTablePointer = __identifier("??_7Internals@WebCore@@6B@");
16694#else
16695 void* expectedVTablePointer = &_ZTVN7WebCore9InternalsE[2];
16696#endif
16697
16698 // If this fails Internals does not have a vtable, so you need to add the
16699 // ImplementationLacksVTable attribute to the interface definition
16700 static_assert(std::is_polymorphic<Internals>::value, "Internals is not polymorphic");
16701
16702 // If you hit this assertion you either have a use after free bug, or
16703 // Internals has subclasses. If Internals has subclasses that get passed
16704 // to toJS() we currently require Internals you to opt out of binding hardening
16705 // by adding the SkipVTableValidation attribute to the interface IDL definition
16706 RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
16707#endif
16708 return createWrapper<Internals>(globalObject, WTFMove(impl));
16709}
16710
16711JSC::JSValue toJS(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, Internals& impl)
16712{
16713 return wrap(lexicalGlobalObject, globalObject, impl);
16714}
16715
16716Internals* JSInternals::toWrapped(JSC::VM& vm, JSC::JSValue value)
16717{
16718 if (auto* wrapper = jsDynamicCast<JSInternals*>(vm, value))
16719 return &wrapper->wrapped();
16720 return nullptr;
16721}
16722
16723}
16724